/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using FilterBackpropWindow3Stride2 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 3, 2>;
TYPED_TEST_SUITE(FilterBackpropWindow3Stride2, GTestTypePairs);
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {396., 560., 344., 552., 777.,
                                         474., 240., 326., 188.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {92.,  102., 112., 142., 152.,
                                         162., 192., 202., 212.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      740.,  792., 1042., 1120., 636., 688., 1026., 1104., 1437.,
      1554., 870., 948.,  428.,  480., 574., 652.,  324.,  376.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {156., 184., 172., 204., 188., 224.,
                                         236., 284., 252., 304., 268., 324.,
                                         316., 384., 332., 404., 348., 424.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1428., 1480., 1532., 1584., 2006., 2084., 2162., 2240., 1220.,
      1272., 1324., 1376., 1974., 2052., 2130., 2208., 2757., 2874.,
      2991., 3108., 1662., 1740., 1818., 1896., 804.,  856.,  908.,
      960.,  1070., 1148., 1226., 1304., 596.,  648.,  700.,  752.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      284., 312., 340., 368., 312., 344., 376., 408., 340., 376., 412., 448.,
      424., 472., 520., 568., 452., 504., 556., 608., 480., 536., 592., 648.,
      564., 632., 700., 768., 592., 664., 736., 808., 620., 696., 772., 848.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1428., 1584., 2012., 2240., 1228., 1376., 1992., 2208., 2793.,
      3108., 1692., 1896., 828.,  960.,  1112., 1304., 628.,  752.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {296., 368., 328., 408., 360., 448.,
                                         456., 568., 488., 608., 520., 648.,
                                         616., 768., 648., 808., 680., 848.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2756., 2856., 3064., 3168., 3874., 4024., 4324., 4480., 2356.,
      2456., 2648., 2752., 3834., 3984., 4260., 4416., 5361., 5586.,
      5982., 6216., 3234., 3384., 3636., 3792., 1556., 1656., 1816.,
      1920., 2074., 2224., 2452., 2608., 1156., 1256., 1400., 1504.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,  592.,  680.,  736.,  596.,  656.,  752.,  816.,  652.,
      720.,  824.,  896.,  820.,  912.,  1040., 1136., 876.,  976.,
      1112., 1216., 932.,  1040., 1184., 1296., 1100., 1232., 1400.,
      1536., 1156., 1296., 1472., 1616., 1212., 1360., 1544., 1696.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5412.,  5512.,  5612.,  5712.,  6024., 6128.,  6232.,  6336.,  7598.,
      7748.,  7898.,  8048.,  8492.,  8648., 8804.,  8960.,  4612.,  4712.,
      4812.,  4912.,  5192.,  5296.,  5400., 5504.,  7518.,  7668.,  7818.,
      7968.,  8364.,  8520.,  8676.,  8832., 10497., 10722., 10947., 11172.,
      11730., 11964., 12198., 12432., 6318., 6468.,  6618.,  6768.,  7116.,
      7272.,  7428.,  7584.,  3012.,  3112., 3212.,  3312.,  3528.,  3632.,
      3736.,  3840.,  3998.,  4148.,  4298., 4448.,  4748.,  4904.,  5060.,
      5216.,  2212.,  2312.,  2412.,  2512., 2696.,  2800.,  2904.,  3008.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1028., 1080., 1132., 1184., 1304., 1360., 1416., 1472., 1132.,
      1192., 1252., 1312., 1440., 1504., 1568., 1632., 1236., 1304.,
      1372., 1440., 1576., 1648., 1720., 1792., 1548., 1640., 1732.,
      1824., 1984., 2080., 2176., 2272., 1652., 1752., 1852., 1952.,
      2120., 2224., 2328., 2432., 1756., 1864., 1972., 2080., 2256.,
      2368., 2480., 2592., 2068., 2200., 2332., 2464., 2664., 2800.,
      2936., 3072., 2172., 2312., 2452., 2592., 2800., 2944., 3088.,
      3232., 2276., 2424., 2572., 2720., 2936., 3088., 3240., 3392.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5412.,  5712.,  6020., 6336., 7610., 8048., 8498., 8960.,  4628.,
      4912.,  5204.,  5504., 7554., 7968., 8394., 8832., 10569., 11172.,
      11793., 12432., 6378., 6768., 7170., 7584., 3060., 3312.,  3572.,
      3840.,  4082.,  4448., 4826., 5216., 2276., 2512., 2756.,  3008.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1052., 1184., 1324., 1472., 1164., 1312., 1468., 1632., 1276.,
      1440., 1612., 1792., 1612., 1824., 2044., 2272., 1724., 1952.,
      2188., 2432., 1836., 2080., 2332., 2592., 2172., 2464., 2764.,
      3072., 2284., 2592., 2908., 3232., 2396., 2720., 3052., 3392.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10628., 10824., 11224., 11424., 11836., 12040., 12464., 12672., 14926.,
      15220., 15796., 16096., 16690., 16996., 17608., 17920., 9060.,  9256.,
      9624.,  9824.,  10204., 10408., 10800., 11008., 14814., 15108., 15636.,
      15936., 16482., 16788., 17352., 17664., 20697., 21138., 21894., 22344.,
      23127., 23586., 24396., 24864., 12462., 12756., 13236., 13536., 14034.,
      14340., 14856., 15168., 5924.,  6120.,  6424.,  6624.,  6940.,  7144.,
      7472.,  7680.,  7870.,  8164.,  8596.,  8896.,  9346.,  9652.,  10120.,
      10432., 4356.,  4552.,  4824.,  5024.,  5308.,  5512.,  5808.,  6016.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2004., 2104., 2264., 2368., 2540., 2648., 2832., 2944., 2212.,
      2328., 2504., 2624., 2812., 2936., 3136., 3264., 2420., 2552.,
      2744., 2880., 3084., 3224., 3440., 3584., 3044., 3224., 3464.,
      3648., 3900., 4088., 4352., 4544., 3252., 3448., 3704., 3904.,
      4172., 4376., 4656., 4864., 3460., 3672., 3944., 4160., 4444.,
      4664., 4960., 5184., 4084., 4344., 4664., 4928., 5260., 5528.,
      5872., 6144., 4292., 4568., 4904., 5184., 5532., 5816., 6176.,
      6464., 4500., 4792., 5144., 5440., 5804., 6104., 6480., 6784.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21060., 21256., 21452., 21648., 22248., 22448., 22648., 22848., 23468.,
      23672., 23876., 24080., 24720., 24928., 25136., 25344., 29558., 29852.,
      30146., 30440., 31292., 31592., 31892., 32192., 33074., 33380., 33686.,
      33992., 34904., 35216., 35528., 35840., 17924., 18120., 18316., 18512.,
      19048., 19248., 19448., 19648., 20204., 20408., 20612., 20816., 21392.,
      21600., 21808., 22016., 29334., 29628., 29922., 30216., 30972., 31272.,
      31572., 31872., 32658., 32964., 33270., 33576., 34392., 34704., 35016.,
      35328., 40953., 41394., 41835., 42276., 43338., 43788., 44238., 44688.,
      45795., 46254., 46713., 47172., 48324., 48792., 49260., 49728., 24630.,
      24924., 25218., 25512., 26172., 26472., 26772., 27072., 27762., 28068.,
      28374., 28680., 29400., 29712., 30024., 30336., 11652., 11848., 12044.,
      12240., 12648., 12848., 13048., 13248., 13676., 13880., 14084., 14288.,
      14736., 14944., 15152., 15360., 15446., 15740., 16034., 16328., 16892.,
      17192., 17492., 17792., 18386., 18692., 18998., 19304., 19928., 20240.,
      20552., 20864., 8516.,  8712.,  8908.,  9104.,  9448.,  9648.,  9848.,
      10048., 10412., 10616., 10820., 11024., 11408., 11616., 11824., 12032.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3908.,  4008.,  4108.,  4208.,  4424.,  4528.,  4632.,  4736.,  4972.,
      5080.,  5188.,  5296.,  5552.,  5664.,  5776.,  5888.,  4308.,  4424.,
      4540.,  4656.,  4888.,  5008.,  5128.,  5248.,  5500.,  5624.,  5748.,
      5872.,  6144.,  6272.,  6400.,  6528.,  4708.,  4840.,  4972.,  5104.,
      5352.,  5488.,  5624.,  5760.,  6028.,  6168.,  6308.,  6448.,  6736.,
      6880.,  7024.,  7168.,  5908.,  6088.,  6268.,  6448.,  6744.,  6928.,
      7112.,  7296.,  7612.,  7800.,  7988.,  8176.,  8512.,  8704.,  8896.,
      9088.,  6308.,  6504.,  6700.,  6896.,  7208.,  7408.,  7608.,  7808.,
      8140.,  8344.,  8548.,  8752.,  9104.,  9312.,  9520.,  9728.,  6708.,
      6920.,  7132.,  7344.,  7672.,  7888.,  8104.,  8320.,  8668.,  8888.,
      9108.,  9328.,  9696.,  9920.,  10144., 10368., 7908.,  8168.,  8428.,
      8688.,  9064.,  9328.,  9592.,  9856.,  10252., 10520., 10788., 11056.,
      11472., 11744., 12016., 12288., 8308.,  8584.,  8860.,  9136.,  9528.,
      9808.,  10088., 10368., 10780., 11064., 11348., 11632., 12064., 12352.,
      12640., 12928., 8708.,  9000.,  9292.,  9584.,  9992.,  10288., 10584.,
      10880., 11308., 11608., 11908., 12208., 12656., 12960., 13264., 13568.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {647., 686., 422., 903., 948.,
                                         579., 377., 398., 230.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {106., 116., 126., 166., 176.,
                                         186., 226., 236., 246.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1204., 1294., 1276., 1372., 780., 844., 1671., 1806., 1752.,
      1896., 1062., 1158., 664.,  754., 700., 796.,  396.,  460.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {180., 212., 196., 232., 212., 252.,
                                         276., 332., 292., 352., 308., 372.,
                                         372., 452., 388., 472., 404., 492.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2318., 2408., 2498., 2588., 2456., 2552., 2648., 2744., 1496.,
      1560., 1624., 1688., 3207., 3342., 3477., 3612., 3360., 3504.,
      3648., 3792., 2028., 2124., 2220., 2316., 1238., 1328., 1418.,
      1508., 1304., 1400., 1496., 1592., 728.,  792.,  856.,  920.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328., 360., 392., 424., 356., 392., 428., 464., 384., 424., 464., 504.,
      496., 552., 608., 664., 524., 584., 644., 704., 552., 616., 680., 744.,
      664., 744., 824., 904., 692., 776., 860., 944., 720., 808., 896., 984.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2336., 2588., 2480., 2744., 1516., 1688., 3261., 3612., 3423.,
      3792., 2076., 2316., 1292., 1508., 1364., 1592., 772.,  920.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {344., 424., 376., 464., 408., 504.,
                                         536., 664., 568., 704., 600., 744.,
                                         728., 904., 760., 944., 792., 984.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4498., 4672., 4996., 5176., 4774., 4960., 5296., 5488., 2908.,
      3032., 3248., 3376., 6261., 6522., 6954., 7224., 6567., 6846.,
      7296., 7584., 3966., 4152., 4440., 4632., 2410., 2584., 2836.,
      3016., 2542., 2728., 2992., 3184., 1420., 1544., 1712., 1840.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  688.,  784.,  848.,  684.,  752.,  856.,  928.,  740.,
      816.,  928.,  1008., 964.,  1072., 1216., 1328., 1020., 1136.,
      1288., 1408., 1076., 1200., 1360., 1488., 1300., 1456., 1648.,
      1808., 1356., 1520., 1720., 1888., 1412., 1584., 1792., 1968.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8822.,  8996.,  9170.,  9344.,  9812.,  9992.,  10172., 10352., 9362.,
      9548.,  9734.,  9920.,  10400., 10592., 10784., 10976., 5692.,  5816.,
      5940.,  6064.,  6368.,  6496.,  6624.,  6752.,  12261., 12522., 12783.,
      13044., 13638., 13908., 14178., 14448., 12855., 13134., 13413., 13692.,
      14304., 14592., 14880., 15168., 7746.,  7932.,  8118.,  8304.,  8688.,
      8880.,  9072.,  9264.,  4646.,  4820.,  4994.,  5168.,  5492.,  5672.,
      5852.,  6032.,  4898.,  5084.,  5270.,  5456.,  5792.,  5984.,  6176.,
      6368.,  2716.,  2840.,  2964.,  3088.,  3296.,  3424.,  3552.,  3680.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1196., 1256., 1316., 1376., 1504., 1568., 1632., 1696., 1300.,
      1368., 1436., 1504., 1640., 1712., 1784., 1856., 1404., 1480.,
      1556., 1632., 1776., 1856., 1936., 2016., 1820., 1928., 2036.,
      2144., 2320., 2432., 2544., 2656., 1924., 2040., 2156., 2272.,
      2456., 2576., 2696., 2816., 2028., 2152., 2276., 2400., 2592.,
      2720., 2848., 2976., 2444., 2600., 2756., 2912., 3136., 3296.,
      3456., 3616., 2548., 2712., 2876., 3040., 3272., 3440., 3608.,
      3776., 2652., 2824., 2996., 3168., 3408., 3584., 3760., 3936.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8858.,  9344.,  9842., 10352., 9410.,  9920.,  10442., 10976., 5732.,
      6064.,  6404.,  6752., 12369., 13044., 13737., 14448., 12981., 13692.,
      14421., 15168., 7842., 8304.,  8778.,  9264.,  4754.,  5168.,  5594.,
      6032.,  5018.,  5456., 5906.,  6368.,  2804.,  3088.,  3380.,  3680.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1376., 1532., 1696., 1340., 1504., 1676., 1856., 1452.,
      1632., 1820., 2016., 1900., 2144., 2396., 2656., 2012., 2272.,
      2540., 2816., 2124., 2400., 2684., 2976., 2572., 2912., 3260.,
      3616., 2684., 3040., 3404., 3776., 2796., 3168., 3548., 3936.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17374., 17716., 18340., 18688., 19330., 19684., 20344., 20704., 18454.,
      18820., 19468., 19840., 20506., 20884., 21568., 21952., 11220., 11464.,
      11880., 12128., 12556., 12808., 13248., 13504., 24225., 24738., 25566.,
      26088., 26943., 27474., 28356., 28896., 25413., 25962., 26826., 27384.,
      28275., 28842., 29760., 30336., 15318., 15684., 16236., 16608., 17178.,
      17556., 18144., 18528., 9166.,  9508.,  9988.,  10336., 10834., 11188.,
      11704., 12064., 9670.,  10036., 10540., 10912., 11434., 11812., 12352.,
      12736., 5364.,  5608.,  5928.,  6176.,  6508.,  6760.,  7104.,  7360.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2340., 2456., 2632., 2752., 2940., 3064., 3264., 3392., 2548.,
      2680., 2872., 3008., 3212., 3352., 3568., 3712., 2756., 2904.,
      3112., 3264., 3484., 3640., 3872., 4032., 3588., 3800., 4072.,
      4288., 4572., 4792., 5088., 5312., 3796., 4024., 4312., 4544.,
      4844., 5080., 5392., 5632., 4004., 4248., 4552., 4800., 5116.,
      5368., 5696., 5952., 4836., 5144., 5512., 5824., 6204., 6520.,
      6912., 7232., 5044., 5368., 5752., 6080., 6476., 6808., 7216.,
      7552., 5252., 5592., 5992., 6336., 6748., 7096., 7520., 7872.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34406., 34748., 35090., 35432., 36332., 36680., 37028., 37376., 38306.,
      38660., 39014., 39368., 40328., 40688., 41048., 41408., 36542., 36908.,
      37274., 37640., 38564., 38936., 39308., 39680., 40634., 41012., 41390.,
      41768., 42752., 43136., 43520., 43904., 22196., 22440., 22684., 22928.,
      23512., 23760., 24008., 24256., 24860., 25112., 25364., 25616., 26240.,
      26496., 26752., 27008., 47937., 48450., 48963., 49476., 50610., 51132.,
      51654., 52176., 53355., 53886., 54417., 54948., 56172., 56712., 57252.,
      57792., 50277., 50826., 51375., 51924., 53094., 53652., 54210., 54768.,
      55983., 56550., 57117., 57684., 58944., 59520., 60096., 60672., 30270.,
      30636., 31002., 31368., 32100., 32472., 32844., 33216., 33978., 34356.,
      34734., 35112., 35904., 36288., 36672., 37056., 17990., 18332., 18674.,
      19016., 19628., 19976., 20324., 20672., 21314., 21668., 22022., 22376.,
      23048., 23408., 23768., 24128., 18974., 19340., 19706., 20072., 20708.,
      21080., 21452., 21824., 22490., 22868., 23246., 23624., 24320., 24704.,
      25088., 25472., 10484., 10728., 10972., 11216., 11608., 11856., 12104.,
      12352., 12764., 13016., 13268., 13520., 13952., 14208., 14464., 14720.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4564.,  4680.,  4796.,  4912.,  5144.,  5264.,  5384.,  5504.,  5756.,
      5880.,  6004.,  6128.,  6400.,  6528.,  6656.,  6784.,  4964.,  5096.,
      5228.,  5360.,  5608.,  5744.,  5880.,  6016.,  6284.,  6424.,  6564.,
      6704.,  6992.,  7136.,  7280.,  7424.,  5364.,  5512.,  5660.,  5808.,
      6072.,  6224.,  6376.,  6528.,  6812.,  6968.,  7124.,  7280.,  7584.,
      7744.,  7904.,  8064.,  6964.,  7176.,  7388.,  7600.,  7928.,  8144.,
      8360.,  8576.,  8924.,  9144.,  9364.,  9584.,  9952.,  10176., 10400.,
      10624., 7364.,  7592.,  7820.,  8048.,  8392.,  8624.,  8856.,  9088.,
      9452.,  9688.,  9924.,  10160., 10544., 10784., 11024., 11264., 7764.,
      8008.,  8252.,  8496.,  8856.,  9104.,  9352.,  9600.,  9980.,  10232.,
      10484., 10736., 11136., 11392., 11648., 11904., 9364.,  9672.,  9980.,
      10288., 10712., 11024., 11336., 11648., 12092., 12408., 12724., 13040.,
      13504., 13824., 14144., 14464., 9764.,  10088., 10412., 10736., 11176.,
      11504., 11832., 12160., 12620., 12952., 13284., 13616., 14096., 14432.,
      14768., 15104., 10164., 10504., 10844., 11184., 11640., 11984., 12328.,
      12672., 13148., 13496., 13844., 14192., 14688., 15040., 15392., 15744.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1508., 1576., 1112., 2102., 2180.,
                                         1530., 868.,  904.,  608.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {311., 332., 353., 479., 500.,
                                         521., 647., 668., 689.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2856., 3016., 2984., 3152., 2098., 2224., 3964., 4204., 4108.,
      4360., 2871., 3060., 1576., 1736., 1640., 1808., 1090., 1216.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      556.,  622., 592.,  664.,  628.,  706.,  844.,  958.,  880.,
      1000., 916., 1042., 1132., 1294., 1168., 1336., 1204., 1378.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5552., 5712., 5872., 6032., 5800., 5968., 6136., 6304., 4070.,
      4196., 4322., 4448., 7688., 7928., 8168., 8408., 7964., 8216.,
      8468., 8720., 5553., 5742., 5931., 6120., 2992., 3152., 3312.,
      3472., 3112., 3280., 3448., 3616., 2054., 2180., 2306., 2432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1046., 1112., 1178., 1244., 1112., 1184., 1256., 1328., 1178.,
      1256., 1334., 1412., 1574., 1688., 1802., 1916., 1640., 1760.,
      1880., 2000., 1706., 1832., 1958., 2084., 2102., 2264., 2426.,
      2588., 2168., 2336., 2504., 2672., 2234., 2408., 2582., 2756.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5584., 6032., 5840., 6304., 4106., 4448., 7784., 8408., 8072.,
      8720., 5643., 6120., 3088., 3472., 3216., 3616., 2138., 2432.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1244., 1148., 1328., 1220., 1412., 1652., 1916., 1724.,
      2000., 1796., 2084., 2228., 2588., 2300., 2672., 2372., 2756.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10856., 11168., 11744., 12064., 11352., 11680., 12272., 12608., 7966.,
      8212.,  8644.,  8896.,  15100., 15568., 16336., 16816., 15652., 16144.,
      16936., 17440., 10917., 11286., 11862., 12240., 5864.,  6176.,  6624.,
      6944.,  6104.,  6432.,  6896.,  7232.,  4030.,  4276.,  4612.,  4864.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2026., 2152., 2356., 2488., 2158., 2296., 2512., 2656., 2290.,
      2440., 2668., 2824., 3082., 3304., 3604., 3832., 3214., 3448.,
      3760., 4000., 3346., 3592., 3916., 4168., 4138., 4456., 4852.,
      5176., 4270., 4600., 5008., 5344., 4402., 4744., 5164., 5512.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21400., 21712., 22024., 22336., 23168., 23488., 23808., 24128., 22376.,
      22704., 23032., 23360., 24208., 24544., 24880., 25216., 15686., 15932.,
      16178., 16424., 17036., 17288., 17540., 17792., 29732., 30200., 30668.,
      31136., 32192., 32672., 33152., 33632., 30812., 31304., 31796., 32288.,
      33368., 33872., 34376., 34880., 21465., 21834., 22203., 22572., 23346.,
      23724., 24102., 24480., 11416., 11728., 12040., 12352., 12928., 13248.,
      13568., 13888., 11880., 12208., 12536., 12864., 13456., 13792., 14128.,
      14464., 7814.,  8060.,  8306.,  8552.,  8972.,  9224.,  9476.,  9728.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3926.,  4052.,  4178., 4304., 4580., 4712., 4844.,  4976.,  4178.,
      4316.,  4454.,  4592., 4880., 5024., 5168., 5312.,  4430.,  4580.,
      4730.,  4880.,  5180., 5336., 5492., 5648., 5942.,  6164.,  6386.,
      6608.,  6980.,  7208., 7436., 7664., 6194., 6428.,  6662.,  6896.,
      7280.,  7520.,  7760., 8000., 6446., 6692., 6938.,  7184.,  7580.,
      7832.,  8084.,  8336., 7958., 8276., 8594., 8912.,  9380.,  9704.,
      10028., 10352., 8210., 8540., 8870., 9200., 9680.,  10016., 10352.,
      10688., 8462.,  8804., 9146., 9488., 9980., 10328., 10676., 11024.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21464., 22336., 23224., 24128., 22456., 23360., 24280., 25216., 15758.,
      16424., 17102., 17792., 29924., 31136., 32372., 33632., 31028., 32288.,
      33572., 34880., 21645., 22572., 23517., 24480., 11608., 12352., 13112.,
      13888., 12088., 12864., 13656., 14464., 7982.,  8552.,  9134.,  9728.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3986.,  4304., 4634., 4976., 4250.,  4592., 4946., 5312.,  4514.,
      4880.,  5258., 5648., 6098., 6608.,  7130., 7664., 6362.,  6896.,
      7442.,  8000., 6626., 7184., 7754.,  8336., 8210., 8912.,  9626.,
      10352., 8474., 9200., 9938., 10688., 8738., 9488., 10250., 11024.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42312., 42928., 44048., 44672., 45816., 46448., 47616., 48256., 44264.,
      44912., 46064., 46720., 47896., 48560., 49760., 50432., 31030., 31516.,
      32356., 32848., 33706., 34204., 35080., 35584., 58924., 59848., 61336.,
      62272., 63796., 64744., 66304., 67264., 61084., 62056., 63592., 64576.,
      66148., 67144., 68752., 69760., 42561., 43290., 44406., 45144., 46287.,
      47034., 48204., 48960., 22600., 23216., 24080., 24704., 25592., 26224.,
      27136., 27776., 23528., 24176., 25072., 25728., 26648., 27312., 28256.,
      28928., 15478., 15964., 16612., 17104., 17770., 18268., 18952., 19456.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7726.,  7972.,  8356.,  8608.,  9010.,  9268.,  9688.,  9952.,  8230.,
      8500.,  8908.,  9184.,  9610.,  9892.,  10336., 10624., 8734.,  9028.,
      9460.,  9760.,  10210., 10516., 10984., 11296., 11758., 12196., 12772.,
      13216., 13810., 14260., 14872., 15328., 12262., 12724., 13324., 13792.,
      14410., 14884., 15520., 16000., 12766., 13252., 13876., 14368., 15010.,
      15508., 16168., 16672., 15790., 16420., 17188., 17824., 18610., 19252.,
      20056., 20704., 16294., 16948., 17740., 18400., 19210., 19876., 20704.,
      21376., 16798., 17476., 18292., 18976., 19810., 20500., 21352., 22048.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84008.,  84624.,  85240.,  85856.,  87472.,  88096.,  88720.,  89344.,
      91000.,  91632.,  92264.,  92896.,  94592.,  95232.,  95872.,  96512.,
      87880.,  88528.,  89176.,  89824.,  91472.,  92128.,  92784.,  93440.,
      95128.,  95792.,  96456.,  97120.,  98848.,  99520.,  100192., 100864.,
      61574.,  62060.,  62546.,  63032.,  64220.,  64712.,  65204.,  65696.,
      66914.,  67412.,  67910.,  68408.,  69656.,  70160.,  70664.,  71168.,
      116924., 117848., 118772., 119696., 121736., 122672., 123608., 124544.,
      126644., 127592., 128540., 129488., 131648., 132608., 133568., 134528.,
      121196., 122168., 123140., 124112., 126200., 127184., 128168., 129152.,
      131300., 132296., 133292., 134288., 136496., 137504., 138512., 139520.,
      84393.,  85122.,  85851.,  86580.,  88074.,  88812.,  89550.,  90288.,
      91827.,  92574.,  93321.,  94068.,  95652.,  96408.,  97164.,  97920.,
      44584.,  45200.,  45816.,  46432.,  47536.,  48160.,  48784.,  49408.,
      50552.,  51184.,  51816.,  52448.,  53632.,  54272.,  54912.,  55552.,
      46408.,  47056.,  47704.,  48352.,  49488.,  50144.,  50800.,  51456.,
      52632.,  53296.,  53960.,  54624.,  55840.,  56512.,  57184.,  57856.,
      30470.,  30956.,  31442.,  31928.,  32732.,  33224.,  33716.,  34208.,
      35042.,  35540.,  36038.,  36536.,  37400.,  37904.,  38408.,  38912.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15206., 15452., 15698., 15944., 16460., 16712., 16964., 17216., 17762.,
      18020., 18278., 18536., 19112., 19376., 19640., 19904., 16190., 16460.,
      16730., 17000., 17540., 17816., 18092., 18368., 18938., 19220., 19502.,
      19784., 20384., 20672., 20960., 21248., 17174., 17468., 17762., 18056.,
      18620., 18920., 19220., 19520., 20114., 20420., 20726., 21032., 21656.,
      21968., 22280., 22592., 23078., 23516., 23954., 24392., 25100., 25544.,
      25988., 26432., 27170., 27620., 28070., 28520., 29288., 29744., 30200.,
      30656., 24062., 24524., 24986., 25448., 26180., 26648., 27116., 27584.,
      28346., 28820., 29294., 29768., 30560., 31040., 31520., 32000., 25046.,
      25532., 26018., 26504., 27260., 27752., 28244., 28736., 29522., 30020.,
      30518., 31016., 31832., 32336., 32840., 33344., 30950., 31580., 32210.,
      32840., 33740., 34376., 35012., 35648., 36578., 37220., 37862., 38504.,
      39464., 40112., 40760., 41408., 31934., 32588., 33242., 33896., 34820.,
      35480., 36140., 36800., 37754., 38420., 39086., 39752., 40736., 41408.,
      42080., 42752., 32918., 33596., 34274., 34952., 35900., 36584., 37268.,
      37952., 38930., 39620., 40310., 41000., 42008., 42704., 43400., 44096.};
  const std::array<int, 4> in_shape = {{1, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {552., 777., 474., 717., 1002.,
                                         609., 320., 431., 248.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {92.,  102., 112., 142., 152.,
                                         162., 192., 202., 212.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1026., 1104., 1437., 1554., 870., 948., 1326., 1434., 1842.,
      2004., 1110., 1218., 568.,  640., 754., 862.,  424.,  496.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {156., 184., 172., 204., 188., 224.,
                                         236., 284., 252., 304., 268., 324.,
                                         316., 384., 332., 404., 348., 424.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1974., 2052., 2130., 2208., 2757., 2874., 2991., 3108., 1662.,
      1740., 1818., 1896., 2544., 2652., 2760., 2868., 3522., 3684.,
      3846., 4008., 2112., 2220., 2328., 2436., 1064., 1136., 1208.,
      1280., 1400., 1508., 1616., 1724., 776.,  848.,  920.,  992.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      284., 312., 340., 368., 312., 344., 376., 408., 340., 376., 412., 448.,
      424., 472., 520., 568., 452., 504., 556., 608., 480., 536., 592., 648.,
      564., 632., 700., 768., 592., 664., 736., 808., 620., 696., 772., 848.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1992., 2208., 2793., 3108., 1692., 1896., 2592., 2868., 3603.,
      4008., 2172., 2436., 1108., 1280., 1472., 1724., 828.,  992.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {296., 368., 328., 408., 360., 448.,
                                         456., 568., 488., 608., 520., 648.,
                                         616., 768., 648., 808., 680., 848.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3834., 3984., 4260., 4416., 5361., 5586., 5982., 6216., 3234.,
      3384., 3636., 3792., 4974., 5184., 5520., 5736., 6891., 7206.,
      7692., 8016., 4134., 4344., 4656., 4872., 2076., 2216., 2416.,
      2560., 2734., 2944., 3232., 3448., 1516., 1656., 1840., 1984.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,  592.,  680.,  736.,  596.,  656.,  752.,  816.,  652.,
      720.,  824.,  896.,  820.,  912.,  1040., 1136., 876.,  976.,
      1112., 1216., 932.,  1040., 1184., 1296., 1100., 1232., 1400.,
      1536., 1156., 1296., 1472., 1616., 1212., 1360., 1544., 1696.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7518.,  7668.,  7818.,  7968.,  8364.,  8520.,  8676.,  8832.,  10497.,
      10722., 10947., 11172., 11730., 11964., 12198., 12432., 6318.,  6468.,
      6618.,  6768.,  7116.,  7272.,  7428.,  7584.,  9738.,  9948.,  10158.,
      10368., 10824., 11040., 11256., 11472., 13467., 13782., 14097., 14412.,
      15060., 15384., 15708., 16032., 8058.,  8268.,  8478.,  8688.,  9096.,
      9312.,  9528.,  9744.,  4012.,  4152.,  4292.,  4432.,  4688.,  4832.,
      4976.,  5120.,  5258.,  5468.,  5678.,  5888.,  6248.,  6464.,  6680.,
      6896.,  2892.,  3032.,  3172.,  3312.,  3536.,  3680.,  3824.,  3968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1028., 1080., 1132., 1184., 1304., 1360., 1416., 1472., 1132.,
      1192., 1252., 1312., 1440., 1504., 1568., 1632., 1236., 1304.,
      1372., 1440., 1576., 1648., 1720., 1792., 1548., 1640., 1732.,
      1824., 1984., 2080., 2176., 2272., 1652., 1752., 1852., 1952.,
      2120., 2224., 2328., 2432., 1756., 1864., 1972., 2080., 2256.,
      2368., 2480., 2592., 2068., 2200., 2332., 2464., 2664., 2800.,
      2936., 3072., 2172., 2312., 2452., 2592., 2800., 2944., 3088.,
      3232., 2276., 2424., 2572., 2720., 2936., 3088., 3240., 3392.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7554.,  7968.,  8394., 8832., 10569., 11172., 11793., 12432., 6378.,
      6768.,  7170.,  7584., 9834., 10368., 10914., 11472., 13629., 14412.,
      15213., 16032., 8178., 8688., 9210.,  9744.,  4100.,  4432.,  4772.,
      5120.,  5402.,  5888., 6386., 6896.,  2996.,  3312.,  3636.,  3968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1052., 1184., 1324., 1472., 1164., 1312., 1468., 1632., 1276.,
      1440., 1612., 1792., 1612., 1824., 2044., 2272., 1724., 1952.,
      2188., 2432., 1836., 2080., 2332., 2592., 2172., 2464., 2764.,
      3072., 2284., 2592., 2908., 3232., 2396., 2720., 3052., 3392.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14814., 15108., 15636., 15936., 16482., 16788., 17352., 17664., 20697.,
      21138., 21894., 22344., 23127., 23586., 24396., 24864., 12462., 12756.,
      13236., 13536., 14034., 14340., 14856., 15168., 19254., 19668., 20316.,
      20736., 21402., 21828., 22512., 22944., 26637., 27258., 28194., 28824.,
      29787., 30426., 31416., 32064., 15942., 16356., 16956., 17376., 17994.,
      18420., 19056., 19488., 7924.,  8200.,  8584.,  8864.,  9260.,  9544.,
      9952.,  10240., 10390., 10804., 11356., 11776., 12346., 12772., 13360.,
      13792., 5716.,  5992.,  6344.,  6624.,  6988.,  7272.,  7648.,  7936.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2004., 2104., 2264., 2368., 2540., 2648., 2832., 2944., 2212.,
      2328., 2504., 2624., 2812., 2936., 3136., 3264., 2420., 2552.,
      2744., 2880., 3084., 3224., 3440., 3584., 3044., 3224., 3464.,
      3648., 3900., 4088., 4352., 4544., 3252., 3448., 3704., 3904.,
      4172., 4376., 4656., 4864., 3460., 3672., 3944., 4160., 4444.,
      4664., 4960., 5184., 4084., 4344., 4664., 4928., 5260., 5528.,
      5872., 6144., 4292., 4568., 4904., 5184., 5532., 5816., 6176.,
      6464., 4500., 4792., 5144., 5440., 5804., 6104., 6480., 6784.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29334., 29628., 29922., 30216., 30972., 31272., 31572., 31872., 32658.,
      32964., 33270., 33576., 34392., 34704., 35016., 35328., 40953., 41394.,
      41835., 42276., 43338., 43788., 44238., 44688., 45795., 46254., 46713.,
      47172., 48324., 48792., 49260., 49728., 24630., 24924., 25218., 25512.,
      26172., 26472., 26772., 27072., 27762., 28068., 28374., 28680., 29400.,
      29712., 30024., 30336., 38094., 38508., 38922., 39336., 40212., 40632.,
      41052., 41472., 42378., 42804., 43230., 43656., 44592., 45024., 45456.,
      45888., 52653., 53274., 53895., 54516., 55758., 56388., 57018., 57648.,
      58935., 59574., 60213., 60852., 62184., 62832., 63480., 64128., 31470.,
      31884., 32298., 32712., 33492., 33912., 34332., 34752., 35562., 35988.,
      36414., 36840., 37680., 38112., 38544., 38976., 15572., 15848., 16124.,
      16400., 16888., 17168., 17448., 17728., 18236., 18520., 18804., 19088.,
      19616., 19904., 20192., 20480., 20366., 20780., 21194., 21608., 22292.,
      22712., 23132., 23552., 24266., 24692., 25118., 25544., 26288., 26720.,
      27152., 27584., 11156., 11432., 11708., 11984., 12408., 12688., 12968.,
      13248., 13692., 13976., 14260., 14544., 15008., 15296., 15584., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3908.,  4008.,  4108.,  4208.,  4424.,  4528.,  4632.,  4736.,  4972.,
      5080.,  5188.,  5296.,  5552.,  5664.,  5776.,  5888.,  4308.,  4424.,
      4540.,  4656.,  4888.,  5008.,  5128.,  5248.,  5500.,  5624.,  5748.,
      5872.,  6144.,  6272.,  6400.,  6528.,  4708.,  4840.,  4972.,  5104.,
      5352.,  5488.,  5624.,  5760.,  6028.,  6168.,  6308.,  6448.,  6736.,
      6880.,  7024.,  7168.,  5908.,  6088.,  6268.,  6448.,  6744.,  6928.,
      7112.,  7296.,  7612.,  7800.,  7988.,  8176.,  8512.,  8704.,  8896.,
      9088.,  6308.,  6504.,  6700.,  6896.,  7208.,  7408.,  7608.,  7808.,
      8140.,  8344.,  8548.,  8752.,  9104.,  9312.,  9520.,  9728.,  6708.,
      6920.,  7132.,  7344.,  7672.,  7888.,  8104.,  8320.,  8668.,  8888.,
      9108.,  9328.,  9696.,  9920.,  10144., 10368., 7908.,  8168.,  8428.,
      8688.,  9064.,  9328.,  9592.,  9856.,  10252., 10520., 10788., 11056.,
      11472., 11744., 12016., 12288., 8308.,  8584.,  8860.,  9136.,  9528.,
      9808.,  10088., 10368., 10780., 11064., 11348., 11632., 12064., 12352.,
      12640., 12928., 8708.,  9000.,  9292.,  9584.,  9992.,  10288., 10584.,
      10880., 11308., 11608., 11908., 12208., 12656., 12960., 13264., 13568.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {903., 948., 579., 1173., 1218.,
                                         741., 503., 524., 302.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {106., 116., 126., 166., 176.,
                                         186., 226., 236., 246.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1671., 1806., 1752., 1896., 1062., 1158., 2157., 2346., 2238.,
      2436., 1350., 1482., 880.,  1006., 916.,  1048., 516.,  604.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {180., 212., 196., 232., 212., 252.,
                                         276., 332., 292., 352., 308., 372.,
                                         372., 452., 388., 472., 404., 492.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3207., 3342., 3477., 3612., 3360., 3504., 3648., 3792., 2028.,
      2124., 2220., 2316., 4125., 4314., 4503., 4692., 4278., 4476.,
      4674., 4872., 2568., 2700., 2832., 2964., 1634., 1760., 1886.,
      2012., 1700., 1832., 1964., 2096., 944.,  1032., 1120., 1208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328., 360., 392., 424., 356., 392., 428., 464., 384., 424., 464., 504.,
      496., 552., 608., 664., 524., 584., 644., 704., 552., 616., 680., 744.,
      664., 744., 824., 904., 692., 776., 860., 944., 720., 808., 896., 984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3261., 3612., 3423., 3792., 2076., 2316., 4233., 4692., 4395.,
      4872., 2652., 2964., 1724., 2012., 1796., 2096., 1012., 1208.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {344., 424., 376., 464., 408., 504.,
                                         536., 664., 568., 704., 600., 744.,
                                         728., 904., 760., 944., 792., 984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6261., 6522., 6954., 7224., 6567., 6846., 7296., 7584., 3966.,
      4152., 4440., 4632., 8097., 8466., 9006., 9384., 8403., 8790.,
      9348., 9744., 5046., 5304., 5664., 5928., 3202., 3448., 3772.,
      4024., 3334., 3592., 3928., 4192., 1852., 2024., 2240., 2416.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  688.,  784.,  848.,  684.,  752.,  856.,  928.,  740.,
      816.,  928.,  1008., 964.,  1072., 1216., 1328., 1020., 1136.,
      1288., 1408., 1076., 1200., 1360., 1488., 1300., 1456., 1648.,
      1808., 1356., 1520., 1720., 1888., 1412., 1584., 1792., 1968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12261., 12522., 12783., 13044., 13638., 13908., 14178., 14448., 12855.,
      13134., 13413., 13692., 14304., 14592., 14880., 15168., 7746.,  7932.,
      8118.,  8304.,  8688.,  8880.,  9072.,  9264.,  15825., 16194., 16563.,
      16932., 17634., 18012., 18390., 18768., 16419., 16806., 17193., 17580.,
      18300., 18696., 19092., 19488., 9834.,  10092., 10350., 10608., 11064.,
      11328., 11592., 11856., 6158.,  6404.,  6650.,  6896.,  7292.,  7544.,
      7796.,  8048.,  6410.,  6668.,  6926.,  7184.,  7592.,  7856.,  8120.,
      8384.,  3532.,  3704.,  3876.,  4048.,  4304.,  4480.,  4656.,  4832.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1196., 1256., 1316., 1376., 1504., 1568., 1632., 1696., 1300.,
      1368., 1436., 1504., 1640., 1712., 1784., 1856., 1404., 1480.,
      1556., 1632., 1776., 1856., 1936., 2016., 1820., 1928., 2036.,
      2144., 2320., 2432., 2544., 2656., 1924., 2040., 2156., 2272.,
      2456., 2576., 2696., 2816., 2028., 2152., 2276., 2400., 2592.,
      2720., 2848., 2976., 2444., 2600., 2756., 2912., 3136., 3296.,
      3456., 3616., 2548., 2712., 2876., 3040., 3272., 3440., 3608.,
      3776., 2652., 2824., 2996., 3168., 3408., 3584., 3760., 3936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12369., 13044., 13737., 14448., 12981., 13692., 14421., 15168., 7842.,
      8304.,  8778.,  9264.,  16041., 16932., 17841., 18768., 16653., 17580.,
      18525., 19488., 10002., 10608., 11226., 11856., 6338.,  6896.,  7466.,
      8048.,  6602.,  7184.,  7778.,  8384.,  3668.,  4048.,  4436.,  4832.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1376., 1532., 1696., 1340., 1504., 1676., 1856., 1452.,
      1632., 1820., 2016., 1900., 2144., 2396., 2656., 2012., 2272.,
      2540., 2816., 2124., 2400., 2684., 2976., 2572., 2912., 3260.,
      3616., 2684., 3040., 3404., 3776., 2796., 3168., 3548., 3936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24225., 24738., 25566., 26088., 26943., 27474., 28356., 28896., 25413.,
      25962., 26826., 27384., 28275., 28842., 29760., 30336., 15318., 15684.,
      16236., 16608., 17178., 17556., 18144., 18528., 31353., 32082., 33126.,
      33864., 34935., 35682., 36780., 37536., 32541., 33306., 34386., 35160.,
      36267., 37050., 38184., 38976., 19494., 20004., 20700., 21216., 21930.,
      22452., 23184., 23712., 12190., 12676., 13300., 13792., 14434., 14932.,
      15592., 16096., 12694., 13204., 13852., 14368., 15034., 15556., 16240.,
      16768., 6996.,  7336.,  7752.,  8096.,  8524.,  8872.,  9312.,  9664.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2340., 2456., 2632., 2752., 2940., 3064., 3264., 3392., 2548.,
      2680., 2872., 3008., 3212., 3352., 3568., 3712., 2756., 2904.,
      3112., 3264., 3484., 3640., 3872., 4032., 3588., 3800., 4072.,
      4288., 4572., 4792., 5088., 5312., 3796., 4024., 4312., 4544.,
      4844., 5080., 5392., 5632., 4004., 4248., 4552., 4800., 5116.,
      5368., 5696., 5952., 4836., 5144., 5512., 5824., 6204., 6520.,
      6912., 7232., 5044., 5368., 5752., 6080., 6476., 6808., 7216.,
      7552., 5252., 5592., 5992., 6336., 6748., 7096., 7520., 7872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47937., 48450., 48963., 49476., 50610., 51132., 51654., 52176., 53355.,
      53886., 54417., 54948., 56172., 56712., 57252., 57792., 50277., 50826.,
      51375., 51924., 53094., 53652., 54210., 54768., 55983., 56550., 57117.,
      57684., 58944., 59520., 60096., 60672., 30270., 30636., 31002., 31368.,
      32100., 32472., 32844., 33216., 33978., 34356., 34734., 35112., 35904.,
      36288., 36672., 37056., 61977., 62706., 63435., 64164., 65514., 66252.,
      66990., 67728., 69123., 69870., 70617., 71364., 72804., 73560., 74316.,
      75072., 64317., 65082., 65847., 66612., 67998., 68772., 69546., 70320.,
      71751., 72534., 73317., 74100., 75576., 76368., 77160., 77952., 38478.,
      38988., 39498., 40008., 40884., 41400., 41916., 42432., 43338., 43860.,
      44382., 44904., 45840., 46368., 46896., 47424., 23894., 24380., 24866.,
      25352., 26108., 26600., 27092., 27584., 28370., 28868., 29366., 29864.,
      30680., 31184., 31688., 32192., 24878., 25388., 25898., 26408., 27188.,
      27704., 28220., 28736., 29546., 30068., 30590., 31112., 31952., 32480.,
      33008., 33536., 13652., 13992., 14332., 14672., 15160., 15504., 15848.,
      16192., 16700., 17048., 17396., 17744., 18272., 18624., 18976., 19328.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4564.,  4680.,  4796.,  4912.,  5144.,  5264.,  5384.,  5504.,  5756.,
      5880.,  6004.,  6128.,  6400.,  6528.,  6656.,  6784.,  4964.,  5096.,
      5228.,  5360.,  5608.,  5744.,  5880.,  6016.,  6284.,  6424.,  6564.,
      6704.,  6992.,  7136.,  7280.,  7424.,  5364.,  5512.,  5660.,  5808.,
      6072.,  6224.,  6376.,  6528.,  6812.,  6968.,  7124.,  7280.,  7584.,
      7744.,  7904.,  8064.,  6964.,  7176.,  7388.,  7600.,  7928.,  8144.,
      8360.,  8576.,  8924.,  9144.,  9364.,  9584.,  9952.,  10176., 10400.,
      10624., 7364.,  7592.,  7820.,  8048.,  8392.,  8624.,  8856.,  9088.,
      9452.,  9688.,  9924.,  10160., 10544., 10784., 11024., 11264., 7764.,
      8008.,  8252.,  8496.,  8856.,  9104.,  9352.,  9600.,  9980.,  10232.,
      10484., 10736., 11136., 11392., 11648., 11904., 9364.,  9672.,  9980.,
      10288., 10712., 11024., 11336., 11648., 12092., 12408., 12724., 13040.,
      13504., 13824., 14144., 14464., 9764.,  10088., 10412., 10736., 11176.,
      11504., 11832., 12160., 12620., 12952., 13284., 13616., 14096., 14432.,
      14768., 15104., 10164., 10504., 10844., 11184., 11640., 11984., 12328.,
      12672., 13148., 13496., 13844., 14192., 14688., 15040., 15392., 15744.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2102., 2180., 1530., 2726., 2804.,
                                         1962., 1156., 1192., 800.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {311., 332., 353., 479., 500.,
                                         521., 647., 668., 689.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3964., 4204., 4108., 4360., 2871., 3060., 5116., 5452., 5260.,
      5608., 3663., 3924., 2088., 2312., 2152., 2384., 1426., 1600.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      556.,  622., 592.,  664.,  628.,  706.,  844.,  958.,  880.,
      1000., 916., 1042., 1132., 1294., 1168., 1336., 1204., 1378.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7688.,  7928.,  8168., 8408., 7964.,  8216.,  8468.,  8720.,  5553.,
      5742.,  5931.,  6120., 9896., 10232., 10568., 10904., 10172., 10520.,
      10868., 11216., 7065., 7326., 7587.,  7848.,  3952.,  4176.,  4400.,
      4624.,  4072.,  4304., 4536., 4768.,  2678.,  2852.,  3026.,  3200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1046., 1112., 1178., 1244., 1112., 1184., 1256., 1328., 1178.,
      1256., 1334., 1412., 1574., 1688., 1802., 1916., 1640., 1760.,
      1880., 2000., 1706., 1832., 1958., 2084., 2102., 2264., 2426.,
      2588., 2168., 2336., 2504., 2672., 2234., 2408., 2582., 2756.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7784.,  8408., 8072., 8720., 5643., 6120., 10088., 10904., 10376.,
      11216., 7227., 7848., 4112., 4624., 4240., 4768.,  2810.,  3200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1244., 1148., 1328., 1220., 1412., 1652., 1916., 1724.,
      2000., 1796., 2084., 2228., 2588., 2300., 2672., 2372., 2756.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15100., 15568., 16336., 16816., 15652., 16144., 16936., 17440., 10917.,
      11286., 11862., 12240., 19516., 20176., 21136., 21808., 20068., 20752.,
      21736., 22432., 13941., 14454., 15174., 15696., 7784.,  8224.,  8800.,
      9248.,  8024.,  8480.,  9072.,  9536.,  5278.,  5620.,  6052.,  6400.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2026., 2152., 2356., 2488., 2158., 2296., 2512., 2656., 2290.,
      2440., 2668., 2824., 3082., 3304., 3604., 3832., 3214., 3448.,
      3760., 4000., 3346., 3592., 3916., 4168., 4138., 4456., 4852.,
      5176., 4270., 4600., 5008., 5344., 4402., 4744., 5164., 5512.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29732., 30200., 30668., 31136., 32192., 32672., 33152., 33632., 30812.,
      31304., 31796., 32288., 33368., 33872., 34376., 34880., 21465., 21834.,
      22203., 22572., 23346., 23724., 24102., 24480., 38372., 39032., 39692.,
      40352., 41600., 42272., 42944., 43616., 39452., 40136., 40820., 41504.,
      42776., 43472., 44168., 44864., 27369., 27882., 28395., 28908., 29826.,
      30348., 30870., 31392., 15128., 15568., 16008., 16448., 17152., 17600.,
      18048., 18496., 15592., 16048., 16504., 16960., 17680., 18144., 18608.,
      19072., 10214., 10556., 10898., 11240., 11756., 12104., 12452., 12800.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3926.,  4052.,  4178., 4304., 4580., 4712., 4844.,  4976.,  4178.,
      4316.,  4454.,  4592., 4880., 5024., 5168., 5312.,  4430.,  4580.,
      4730.,  4880.,  5180., 5336., 5492., 5648., 5942.,  6164.,  6386.,
      6608.,  6980.,  7208., 7436., 7664., 6194., 6428.,  6662.,  6896.,
      7280.,  7520.,  7760., 8000., 6446., 6692., 6938.,  7184.,  7580.,
      7832.,  8084.,  8336., 7958., 8276., 8594., 8912.,  9380.,  9704.,
      10028., 10352., 8210., 8540., 8870., 9200., 9680.,  10016., 10352.,
      10688., 8462.,  8804., 9146., 9488., 9980., 10328., 10676., 11024.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29924., 31136., 32372., 33632., 31028., 32288., 33572., 34880., 21645.,
      22572., 23517., 24480., 38756., 40352., 41972., 43616., 39860., 41504.,
      43172., 44864., 27693., 28908., 30141., 31392., 15448., 16448., 17464.,
      18496., 15928., 16960., 18008., 19072., 10478., 11240., 12014., 12800.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3986.,  4304., 4634., 4976., 4250.,  4592., 4946., 5312.,  4514.,
      4880.,  5258., 5648., 6098., 6608.,  7130., 7664., 6362.,  6896.,
      7442.,  8000., 6626., 7184., 7754.,  8336., 8210., 8912.,  9626.,
      10352., 8474., 9200., 9938., 10688., 8738., 9488., 10250., 11024.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58924., 59848., 61336., 62272., 63796., 64744., 66304., 67264., 61084.,
      62056., 63592., 64576., 66148., 67144., 68752., 69760., 42561., 43290.,
      44406., 45144., 46287., 47034., 48204., 48960., 76204., 77512., 79384.,
      80704., 82612., 83944., 85888., 87232., 78364., 79720., 81640., 83008.,
      84964., 86344., 88336., 89728., 54369., 55386., 56790., 57816., 59247.,
      60282., 61740., 62784., 30024., 30896., 32016., 32896., 34040., 34928.,
      36096., 36992., 30952., 31856., 33008., 33920., 35096., 36016., 37216.,
      38144., 20278., 20956., 21796., 22480., 23338., 24028., 24904., 25600.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7726.,  7972.,  8356.,  8608.,  9010.,  9268.,  9688.,  9952.,  8230.,
      8500.,  8908.,  9184.,  9610.,  9892.,  10336., 10624., 8734.,  9028.,
      9460.,  9760.,  10210., 10516., 10984., 11296., 11758., 12196., 12772.,
      13216., 13810., 14260., 14872., 15328., 12262., 12724., 13324., 13792.,
      14410., 14884., 15520., 16000., 12766., 13252., 13876., 14368., 15010.,
      15508., 16168., 16672., 15790., 16420., 17188., 17824., 18610., 19252.,
      20056., 20704., 16294., 16948., 17740., 18400., 19210., 19876., 20704.,
      21376., 16798., 17476., 18292., 18976., 19810., 20500., 21352., 22048.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      116924., 117848., 118772., 119696., 121736., 122672., 123608., 124544.,
      126644., 127592., 128540., 129488., 131648., 132608., 133568., 134528.,
      121196., 122168., 123140., 124112., 126200., 127184., 128168., 129152.,
      131300., 132296., 133292., 134288., 136496., 137504., 138512., 139520.,
      84393.,  85122.,  85851.,  86580.,  88074.,  88812.,  89550.,  90288.,
      91827.,  92574.,  93321.,  94068.,  95652.,  96408.,  97164.,  97920.,
      151100., 152408., 153716., 155024., 157448., 158768., 160088., 161408.,
      163892., 165224., 166556., 167888., 170432., 171776., 173120., 174464.,
      155372., 156728., 158084., 159440., 161912., 163280., 164648., 166016.,
      168548., 169928., 171308., 172688., 175280., 176672., 178064., 179456.,
      107721., 108738., 109755., 110772., 112554., 113580., 114606., 115632.,
      117459., 118494., 119529., 120564., 122436., 123480., 124524., 125568.,
      59176.,  60048.,  60920.,  61792.,  63152.,  64032.,  64912.,  65792.,
      67192.,  68080.,  68968.,  69856.,  71296.,  72192.,  73088.,  73984.,
      61000.,  61904.,  62808.,  63712.,  65104.,  66016.,  66928.,  67840.,
      69272.,  70192.,  71112.,  72032.,  73504.,  74432.,  75360.,  76288.,
      39878.,  40556.,  41234.,  41912.,  42908.,  43592.,  44276.,  44960.,
      45986.,  46676.,  47366.,  48056.,  49112.,  49808.,  50504.,  51200.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15206., 15452., 15698., 15944., 16460., 16712., 16964., 17216., 17762.,
      18020., 18278., 18536., 19112., 19376., 19640., 19904., 16190., 16460.,
      16730., 17000., 17540., 17816., 18092., 18368., 18938., 19220., 19502.,
      19784., 20384., 20672., 20960., 21248., 17174., 17468., 17762., 18056.,
      18620., 18920., 19220., 19520., 20114., 20420., 20726., 21032., 21656.,
      21968., 22280., 22592., 23078., 23516., 23954., 24392., 25100., 25544.,
      25988., 26432., 27170., 27620., 28070., 28520., 29288., 29744., 30200.,
      30656., 24062., 24524., 24986., 25448., 26180., 26648., 27116., 27584.,
      28346., 28820., 29294., 29768., 30560., 31040., 31520., 32000., 25046.,
      25532., 26018., 26504., 27260., 27752., 28244., 28736., 29522., 30020.,
      30518., 31016., 31832., 32336., 32840., 33344., 30950., 31580., 32210.,
      32840., 33740., 34376., 35012., 35648., 36578., 37220., 37862., 38504.,
      39464., 40112., 40760., 41408., 31934., 32588., 33242., 33896., 34820.,
      35480., 36140., 36800., 37754., 38420., 39086., 39752., 40736., 41408.,
      42080., 42752., 32918., 33596., 34274., 34952., 35900., 36584., 37268.,
      37952., 38930., 39620., 40310., 41000., 42008., 42704., 43400., 44096.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1312., 1870., 1168., 1592., 2260.,
                                         1408., 882.,  1227., 744.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {335., 356., 377., 440., 461.,
                                         482., 545., 566., 587.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2480., 2624., 3524., 3740., 2192., 2336., 3000., 3184., 4244.,
      4520., 2632., 2816., 1626., 1764., 2247., 2454., 1350., 1488.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      598., 670., 634., 712., 670.,  754., 778.,  880.,  814.,
      922., 850., 964., 958., 1090., 994., 1132., 1030., 1174.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4816., 4960., 5104., 5248., 6832., 7048., 7264., 7480., 4240.,
      4384., 4528., 4672., 5816., 6000., 6184., 6368., 8212., 8488.,
      8764., 9040., 5080., 5264., 5448., 5632., 3114., 3252., 3390.,
      3528., 4287., 4494., 4701., 4908., 2562., 2700., 2838., 2976.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1124., 1196., 1268., 1340., 1190., 1268., 1346., 1424., 1256.,
      1340., 1424., 1508., 1454., 1556., 1658., 1760., 1520., 1628.,
      1736., 1844., 1586., 1700., 1814., 1928., 1784., 1916., 2048.,
      2180., 1850., 1988., 2126., 2264., 1916., 2060., 2204., 2348.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4856., 5248., 6904., 7480., 4296., 4672., 5896., 6368., 8344.,
      9040., 5176., 5632., 3192., 3528., 4413., 4908., 2652., 2976.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1160., 1340., 1232., 1424., 1304., 1508., 1520., 1760., 1592.,
      1844., 1664., 1928., 1880., 2180., 1952., 2264., 2024., 2348.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9432.,  9712.,  10208., 10496., 13388., 13808., 14528., 14960., 8312.,
      8592.,  9056.,  9344.,  11432., 11792., 12368., 12736., 16148., 16688.,
      17528., 18080., 9992.,  10352., 10896., 11264., 6114.,  6384.,  6780.,
      7056.,  8421.,  8826.,  9402.,  9816.,  5034.,  5304.,  5676.,  5952.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2182., 2320., 2536., 2680., 2314., 2464., 2692., 2848., 2446.,
      2608., 2848., 3016., 2842., 3040., 3316., 3520., 2974., 3184.,
      3472., 3688., 3106., 3328., 3628., 3856., 3502., 3760., 4096.,
      4360., 3634., 3904., 4252., 4528., 3766., 4048., 4408., 4696.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18584., 18864., 19144., 19424., 20128., 20416., 20704., 20992., 26356.,
      26776., 27196., 27616., 28624., 29056., 29488., 29920., 16344., 16624.,
      16904., 17184., 17824., 18112., 18400., 18688., 22504., 22864., 23224.,
      23584., 24368., 24736., 25104., 25472., 31756., 32296., 32836., 33376.,
      34504., 35056., 35608., 36160., 19624., 19984., 20344., 20704., 21424.,
      21792., 22160., 22528., 11958., 12228., 12498., 12768., 13284., 13560.,
      13836., 14112., 16437., 16842., 17247., 17652., 18390., 18804., 19218.,
      19632., 9798.,  10068., 10338., 10608., 11076., 11352., 11628., 11904.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4226., 4364., 4502., 4640., 4928., 5072., 5216., 5360., 4478.,
      4628., 4778., 4928., 5228., 5384., 5540., 5696., 4730., 4892.,
      5054., 5216., 5528., 5696., 5864., 6032., 5486., 5684., 5882.,
      6080., 6428., 6632., 6836., 7040., 5738., 5948., 6158., 6368.,
      6728., 6944., 7160., 7376., 5990., 6212., 6434., 6656., 7028.,
      7256., 7484., 7712., 6746., 7004., 7262., 7520., 7928., 8192.,
      8456., 8720., 6998., 7268., 7538., 7808., 8228., 8504., 8780.,
      9056., 7250., 7532., 7814., 8096., 8528., 8816., 9104., 9392.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18664., 19424., 20200., 20992., 26500., 27616., 28756., 29920., 16456.,
      17184., 17928., 18688., 22664., 23584., 24520., 25472., 32020., 33376.,
      34756., 36160., 19816., 20704., 21608., 22528., 12114., 12768., 13434.,
      14112., 16689., 17652., 18633., 19632., 9978.,  10608., 11250., 11904.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4298., 4640., 4994., 5360., 4562., 4928., 5306., 5696., 4826.,
      5216., 5618., 6032., 5618., 6080., 6554., 7040., 5882., 6368.,
      6866., 7376., 6146., 6656., 7178., 7712., 6938., 7520., 8114.,
      8720., 7202., 7808., 8426., 9056., 7466., 8096., 8738., 9392.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36776., 37328., 38288., 38848., 39832., 40400., 41408., 41984., 52172.,
      53000., 54392., 55232., 56660., 57512., 58976., 59840., 32360., 32912.,
      33808., 34368., 35288., 35856., 36800., 37376., 44616., 45328., 46448.,
      47168., 48312., 49040., 50208., 50944., 62972., 64040., 65672., 66752.,
      68420., 69512., 71216., 72320., 38920., 39632., 40688., 41408., 42488.,
      43216., 44320., 45056., 23694., 24228., 24996., 25536., 26322., 26868.,
      27672., 28224., 32577., 33378., 34494., 35304., 36447., 37266., 38436.,
      39264., 19422., 19956., 20676., 21216., 21954., 22500., 23256., 23808.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8326.,  8596.,  9004.,  9280.,  9706.,  9988.,  10432., 10720., 8830.,
      9124.,  9556.,  9856.,  10306., 10612., 11080., 11392., 9334.,  9652.,
      10108., 10432., 10906., 11236., 11728., 12064., 10846., 11236., 11764.,
      12160., 12706., 13108., 13672., 14080., 11350., 11764., 12316., 12736.,
      13306., 13732., 14320., 14752., 11854., 12292., 12868., 13312., 13906.,
      14356., 14968., 15424., 13366., 13876., 14524., 15040., 15706., 16228.,
      16912., 17440., 13870., 14404., 15076., 15616., 16306., 16852., 17560.,
      18112., 14374., 14932., 15628., 16192., 16906., 17476., 18208., 18784.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73000.,  73552.,  74104.,  74656.,  76016.,  76576.,  77136.,  77696.,
      79096.,  79664.,  80232.,  80800.,  82240.,  82816.,  83392.,  83968.,
      103516., 104344., 105172., 106000., 107944., 108784., 109624., 110464.,
      112468., 113320., 114172., 115024., 117088., 117952., 118816., 119680.,
      64168.,  64720.,  65272.,  65824.,  67056.,  67616.,  68176.,  68736.,
      70008.,  70576.,  71144.,  71712.,  73024.,  73600.,  74176.,  74752.,
      88520.,  89232.,  89944.,  90656.,  92176.,  92896.,  93616.,  94336.,
      95896.,  96624.,  97352.,  98080.,  99680.,  100416., 101152., 101888.,
      124876., 125944., 127012., 128080., 130264., 131344., 132424., 133504.,
      135748., 136840., 137932., 139024., 141328., 142432., 143536., 144640.,
      77128.,  77840.,  78552.,  79264.,  80656.,  81376.,  82096.,  82816.,
      84248.,  84976.,  85704.,  86432.,  87904.,  88640.,  89376.,  90112.,
      46854.,  47388.,  47922.,  48456.,  49452.,  49992.,  50532.,  51072.,
      52098.,  52644.,  53190.,  53736.,  54792.,  55344.,  55896.,  56448.,
      64353.,  65154.,  65955.,  66756.,  68178.,  68988.,  69798.,  70608.,
      72075.,  72894.,  73713.,  74532.,  76044.,  76872.,  77700.,  78528.,
      38310.,  38844.,  39378.,  39912.,  40812.,  41352.,  41892.,  42432.,
      43362.,  43908.,  44454.,  45000.,  45960.,  46512.,  47064.,  47616.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16382., 16652., 16922., 17192., 17732., 18008., 18284., 18560., 19130.,
      19412., 19694., 19976., 20576., 20864., 21152., 21440., 17366., 17660.,
      17954., 18248., 18812., 19112., 19412., 19712., 20306., 20612., 20918.,
      21224., 21848., 22160., 22472., 22784., 18350., 18668., 18986., 19304.,
      19892., 20216., 20540., 20864., 21482., 21812., 22142., 22472., 23120.,
      23456., 23792., 24128., 21302., 21692., 22082., 22472., 23132., 23528.,
      23924., 24320., 25010., 25412., 25814., 26216., 26936., 27344., 27752.,
      28160., 22286., 22700., 23114., 23528., 24212., 24632., 25052., 25472.,
      26186., 26612., 27038., 27464., 28208., 28640., 29072., 29504., 23270.,
      23708., 24146., 24584., 25292., 25736., 26180., 26624., 27362., 27812.,
      28262., 28712., 29480., 29936., 30392., 30848., 26222., 26732., 27242.,
      27752., 28532., 29048., 29564., 30080., 30890., 31412., 31934., 32456.,
      33296., 33824., 34352., 34880., 27206., 27740., 28274., 28808., 29612.,
      30152., 30692., 31232., 32066., 32612., 33158., 33704., 34568., 35120.,
      35672., 36224., 28190., 28748., 29306., 29864., 30692., 31256., 31820.,
      32384., 33242., 33812., 34382., 34952., 35840., 36416., 36992., 37568.};
  const std::array<int, 4> in_shape = {{1, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2194., 2272., 1420., 2662., 2740.,
                                         1708., 1443., 1488., 903.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {393., 414., 435., 519., 540.,
                                         561., 645., 666., 687.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4136., 4388., 4280., 4544., 2664., 2840., 5000., 5324., 5144.,
      5480., 3192., 3416., 2643., 2886., 2724., 2976., 1638., 1806.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      702.,  786., 738.,  828.,  774.,  870.,  918.,  1038., 954.,
      1080., 990., 1122., 1134., 1290., 1170., 1332., 1206., 1374.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8020.,  8272.,  8524., 8776., 8296.,  8560.,  8824.,  9088., 5152.,
      5328.,  5504.,  5680., 9676., 10000., 10324., 10648., 9952., 10288.,
      10624., 10960., 6160., 6384., 6608.,  6832.,  5043.,  5286., 5529.,
      5772.,  5196.,  5448., 5700., 5952.,  3108.,  3276.,  3444., 3612.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1320., 1404., 1488., 1572., 1386., 1476., 1566., 1656., 1452.,
      1548., 1644., 1740., 1716., 1836., 1956., 2076., 1782., 1908.,
      2034., 2160., 1848., 1980., 2112., 2244., 2112., 2268., 2424.,
      2580., 2178., 2340., 2502., 2664., 2244., 2412., 2580., 2748.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8128.,  8776., 8416., 9088., 5240., 5680., 9856., 10648., 10144.,
      10960., 6296., 6832., 5205., 5772., 5367., 5952., 3228.,  3612.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1368., 1572., 1440., 1656., 1512., 1740., 1800., 2076., 1872.,
      2160., 1944., 2244., 2232., 2580., 2304., 2664., 2376., 2748.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15764., 16256., 17048., 17552., 16316., 16832., 17648., 18176., 10136.,
      10480., 11008., 11360., 19076., 19712., 20648., 21296., 19628., 20288.,
      21248., 21920., 12152., 12592., 13216., 13664., 9933.,  10410., 11058.,
      11544., 10239., 10734., 11400., 11904., 6126.,  6456.,  6888.,  7224.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2574., 2736., 2976., 3144., 2706., 2880., 3132., 3312., 2838.,
      3024., 3288., 3480., 3366., 3600., 3912., 4152., 3498., 3744.,
      4068., 4320., 3630., 3888., 4224., 4488., 4158., 4464., 4848.,
      5160., 4290., 4608., 5004., 5328., 4422., 4752., 5160., 5496.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31036., 31528., 32020., 32512., 33592., 34096., 34600., 35104., 32116.,
      32632., 33148., 33664., 34768., 35296., 35824., 36352., 19928., 20272.,
      20616., 20960., 21664., 22016., 22368., 22720., 37516., 38152., 38788.,
      39424., 40648., 41296., 41944., 42592., 38596., 39256., 39916., 40576.,
      41824., 42496., 43168., 43840., 23864., 24304., 24744., 25184., 25984.,
      26432., 26880., 27328., 19389., 19866., 20343., 20820., 21630., 22116.,
      22602., 23088., 19983., 20478., 20973., 21468., 22296., 22800., 23304.,
      23808., 11922., 12252., 12582., 12912., 13440., 13776., 14112., 14448.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4986.,  5148.,  5310., 5472., 5784., 5952., 6120.,  6288.,  5238.,
      5412.,  5586.,  5760., 6084., 6264., 6444., 6624.,  5490.,  5676.,
      5862.,  6048.,  6384., 6576., 6768., 6960., 6498.,  6732.,  6966.,
      7200.,  7584.,  7824., 8064., 8304., 6750., 6996.,  7242.,  7488.,
      7884.,  8136.,  8388., 8640., 7002., 7260., 7518.,  7776.,  8184.,
      8448.,  8712.,  8976., 8010., 8316., 8622., 8928.,  9384.,  9696.,
      10008., 10320., 8262., 8580., 8898., 9216., 9684.,  10008., 10332.,
      10656., 8514.,  8844., 9174., 9504., 9984., 10320., 10656., 10992.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31252., 32512., 33796., 35104., 32356., 33664., 34996., 36352., 20104.,
      20960., 21832., 22720., 37876., 39424., 40996., 42592., 38980., 40576.,
      42196., 43840., 24136., 25184., 26248., 27328., 19713., 20820., 21945.,
      23088., 20325., 21468., 22629., 23808., 12162., 12912., 13674., 14448.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5082.,  5472., 5874., 6288., 5346.,  5760., 6186., 6624.,  5610.,
      6048.,  6498., 6960., 6666., 7200.,  7746., 8304., 6930.,  7488.,
      8058.,  8640., 7194., 7776., 8370.,  8976., 8250., 8928.,  9618.,
      10320., 8514., 9216., 9930., 10656., 8778., 9504., 10242., 10992.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61532., 62504., 64040., 65024., 66596., 67592., 69200., 70208., 63692.,
      64712., 66296., 67328., 68948., 69992., 71648., 72704., 39528., 40208.,
      41232., 41920., 42968., 43664., 44736., 45440., 74492., 75752., 77576.,
      78848., 80708., 81992., 83888., 85184., 76652., 77960., 79832., 81152.,
      83060., 84392., 86336., 87680., 47400., 48272., 49488., 50368., 51608.,
      52496., 53760., 54656., 38481., 39426., 40686., 41640., 42927., 43890.,
      45204., 46176., 39669., 40650., 41946., 42936., 44259., 45258., 46608.,
      47616., 23670., 24324., 25164., 25824., 26682., 27348., 28224., 28896.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9846.,  10164., 10620., 10944., 11418., 11748., 12240., 12576., 10350.,
      10692., 11172., 11520., 12018., 12372., 12888., 13248., 10854., 11220.,
      11724., 12096., 12618., 12996., 13536., 13920., 12870., 13332., 13932.,
      14400., 15018., 15492., 16128., 16608., 13374., 13860., 14484., 14976.,
      15618., 16116., 16776., 17280., 13878., 14388., 15036., 15552., 16218.,
      16740., 17424., 17952., 15894., 16500., 17244., 17856., 18618., 19236.,
      20016., 20640., 16398., 17028., 17796., 18432., 19218., 19860., 20664.,
      21312., 16902., 17556., 18348., 19008., 19818., 20484., 21312., 21984.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      122092., 123064., 124036., 125008., 127096., 128080., 129064., 130048.,
      132196., 133192., 134188., 135184., 137392., 138400., 139408., 140416.,
      126364., 127384., 128404., 129424., 131560., 132592., 133624., 134656.,
      136852., 137896., 138940., 139984., 142240., 143296., 144352., 145408.,
      78376.,  79056.,  79736.,  80416.,  81776.,  82464.,  83152.,  83840.,
      85240.,  85936.,  86632.,  87328.,  88768.,  89472.,  90176.,  90880.,
      147724., 148984., 150244., 151504., 153880., 155152., 156424., 157696.,
      160132., 161416., 162700., 163984., 166480., 167776., 169072., 170368.,
      151996., 153304., 154612., 155920., 158344., 159664., 160984., 162304.,
      164788., 166120., 167452., 168784., 171328., 172672., 174016., 175360.,
      93928.,  94800.,  95672.,  96544.,  98096.,  98976.,  99856.,  100736.,
      102328., 103216., 104104., 104992., 106624., 107520., 108416., 109312.,
      76017.,  76962.,  77907.,  78852.,  80418.,  81372.,  82326.,  83280.,
      84891.,  85854.,  86817.,  87780.,  89436.,  90408.,  91380.,  92352.,
      78357.,  79338.,  80319.,  81300.,  82902.,  83892.,  84882.,  85872.,
      87519.,  88518.,  89517.,  90516.,  92208.,  93216.,  94224.,  95232.,
      46686.,  47340.,  47994.,  48648.,  49668.,  50328.,  50988.,  51648.,
      52698.,  53364.,  54030.,  54696.,  55776.,  56448.,  57120.,  57792.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19374., 19692., 20010., 20328., 20916., 21240., 21564., 21888., 22506.,
      22836., 23166., 23496., 24144., 24480., 24816., 25152., 20358., 20700.,
      21042., 21384., 21996., 22344., 22692., 23040., 23682., 24036., 24390.,
      24744., 25416., 25776., 26136., 26496., 21342., 21708., 22074., 22440.,
      23076., 23448., 23820., 24192., 24858., 25236., 25614., 25992., 26688.,
      27072., 27456., 27840., 25278., 25740., 26202., 26664., 27396., 27864.,
      28332., 28800., 29562., 30036., 30510., 30984., 31776., 32256., 32736.,
      33216., 26262., 26748., 27234., 27720., 28476., 28968., 29460., 29952.,
      30738., 31236., 31734., 32232., 33048., 33552., 34056., 34560., 27246.,
      27756., 28266., 28776., 29556., 30072., 30588., 31104., 31914., 32436.,
      32958., 33480., 34320., 34848., 35376., 35904., 31182., 31788., 32394.,
      33000., 33876., 34488., 35100., 35712., 36618., 37236., 37854., 38472.,
      39408., 40032., 40656., 41280., 32166., 32796., 33426., 34056., 34956.,
      35592., 36228., 36864., 37794., 38436., 39078., 39720., 40680., 41328.,
      41976., 42624., 33150., 33804., 34458., 35112., 36036., 36696., 37356.,
      38016., 38970., 39636., 40302., 40968., 41952., 42624., 43296., 43968.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5128., 5264., 3760., 6216., 6352.,
                                         4528., 3350., 3428., 2394.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1155., 1200., 1245., 1515., 1560.,
                                         1605., 1875., 1920., 1965.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9808.,  10256., 10064., 10528., 7172., 7520., 11856., 12432., 12112.,
      12704., 8612.,  9056.,  6268.,  6700., 6412., 6856.,  4455.,  4788.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2139., 2310., 2220., 2400., 2301., 2490., 2787., 3030., 2868.,
      3120., 2949., 3210., 3435., 3750., 3516., 3840., 3597., 3930.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19168., 19616., 20064., 20512., 19664., 20128., 20592., 21056., 13996.,
      14344., 14692., 15040., 23136., 23712., 24288., 24864., 23632., 24224.,
      24816., 25408., 16780., 17224., 17668., 18112., 12104., 12536., 12968.,
      13400., 12380., 12824., 13268., 13712., 8577.,  8910.,  9243.,  9576.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4107., 4278., 4449., 4620., 4260., 4440., 4620., 4800., 4413.,
      4602., 4791., 4980., 5331., 5574., 5817., 6060., 5484., 5736.,
      5988., 6240., 5637., 5898., 6159., 6420., 6555., 6870., 7185.,
      7500., 6708., 7032., 7356., 7680., 6861., 7194., 7527., 7860.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19360., 20512., 19872., 21056., 14164., 15040., 23456., 24864., 23968.,
      25408., 17044., 18112., 12392., 13400., 12680., 13712., 8811.,  9576.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4197., 4620., 4359., 4800., 4521., 4980., 5493., 6060., 5655.,
      6240., 5817., 6420., 6789., 7500., 6951., 7680., 7113., 7860.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37840., 38720., 40128., 41024., 38832., 39744., 41184., 42112., 27644.,
      28328., 29384., 30080., 45776., 46912., 48576., 49728., 46768., 47936.,
      49632., 50816., 33212., 34088., 35336., 36224., 23932., 24784., 25936.,
      26800., 24484., 25360., 26536., 27424., 16965., 17622., 18486., 19152.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8061.,  8394.,  8898.,  9240.,  8367.,  8718.,  9240.,  9600.,  8673.,
      9042.,  9582.,  9960.,  10509., 10986., 11634., 12120., 10815., 11310.,
      11976., 12480., 11121., 11634., 12318., 12840., 12957., 13578., 14370.,
      15000., 13263., 13902., 14712., 15360., 13569., 14226., 15054., 15720.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74800., 75680., 76560.,  77440.,  79360., 80256., 81152., 82048., 76752.,
      77664., 78576., 79488.,  81440.,  82368., 83296., 84224., 54604., 55288.,
      55972., 56656., 58072.,  58768.,  59464., 60160., 90416., 91552., 92688.,
      93824., 96000., 97152.,  98304.,  99456., 92368., 93536., 94704., 95872.,
      98080., 99264., 100448., 101632., 65548., 66424., 67300., 68176., 69784.,
      70672., 71560., 72448.,  47012.,  47864., 48716., 49568., 51008., 51872.,
      52736., 53600., 48092.,  48968.,  49844., 50720., 52184., 53072., 53960.,
      54848., 33273., 33930.,  34587.,  35244., 36306., 36972., 37638., 38304.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15789., 16122., 16455., 16788., 17454., 17796., 18138., 18480., 16383.,
      16734., 17085., 17436., 18120., 18480., 18840., 19200., 16977., 17346.,
      17715., 18084., 18786., 19164., 19542., 19920., 20541., 21018., 21495.,
      21972., 22782., 23268., 23754., 24240., 21135., 21630., 22125., 22620.,
      23448., 23952., 24456., 24960., 21729., 22242., 22755., 23268., 24114.,
      24636., 25158., 25680., 25293., 25914., 26535., 27156., 28110., 28740.,
      29370., 30000., 25887., 26526., 27165., 27804., 28776., 29424., 30072.,
      30720., 26481., 27138., 27795., 28452., 29442., 30108., 30774., 31440.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75184., 77440.,  79728., 82048., 77168., 79488., 81840., 84224., 54940.,
      56656., 58396.,  60160., 91056., 93824., 96624., 99456., 93040., 95872.,
      98736., 101632., 66076., 68176., 70300., 72448., 47588., 49568., 51572.,
      53600., 48692.,  50720., 52772., 54848., 33741., 35244., 36765., 38304.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15969., 16788., 17625., 18480., 16581., 17436., 18309., 19200., 17193.,
      18084., 18993., 19920., 20865., 21972., 23097., 24240., 21477., 22620.,
      23781., 24960., 22089., 23268., 24465., 25680., 25761., 27156., 28569.,
      30000., 26373., 27804., 29253., 30720., 26985., 28452., 29937., 31440.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      148624., 150368., 153120., 154880., 157680., 159456., 162304., 164096.,
      152528., 154336., 157152., 158976., 161840., 163680., 166592., 168448.,
      108524., 109880., 111944., 113312., 115412., 116792., 118928., 120320.,
      179856., 182112., 185376., 187648., 190960., 193248., 196608., 198912.,
      183760., 186080., 189408., 191744., 195120., 197472., 200896., 203264.,
      130412., 132152., 134600., 136352., 138836., 140600., 143120., 144896.,
      93484.,  95176.,  97432.,  99136.,  101428., 103144., 105472., 107200.,
      95644.,  97384.,  99688.,  101440., 103780., 105544., 107920., 109696.,
      66177.,  67482.,  69174.,  70488.,  72207.,  73530.,  75276.,  76608.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31281., 31938., 32910., 33576., 34575., 35250., 36276., 36960., 32469.,
      33162., 34170., 34872., 35907., 36618., 37680., 38400., 33657., 34386.,
      35430., 36168., 37239., 37986., 39084., 39840., 40785., 41730., 42990.,
      43944., 45231., 46194., 47508., 48480., 41973., 42954., 44250., 45240.,
      46563., 47562., 48912., 49920., 43161., 44178., 45510., 46536., 47895.,
      48930., 50316., 51360., 50289., 51522., 53070., 54312., 55887., 57138.,
      58740., 60000., 51477., 52746., 54330., 55608., 57219., 58506., 60144.,
      61440., 52665., 53970., 55590., 56904., 58551., 59874., 61548., 62880.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      295504., 297248., 298992., 300736., 304480., 306240., 308000., 309760.,
      313584., 315360., 317136., 318912., 322816., 324608., 326400., 328192.,
      303248., 305056., 306864., 308672., 312480., 314304., 316128., 317952.,
      321840., 323680., 325520., 327360., 331328., 333184., 335040., 336896.,
      215692., 217048., 218404., 219760., 222520., 223888., 225256., 226624.,
      229444., 230824., 232204., 233584., 236464., 237856., 239248., 240640.,
      357456., 359712., 361968., 364224., 368480., 370752., 373024., 375296.,
      379632., 381920., 384208., 386496., 390912., 393216., 395520., 397824.,
      365200., 367520., 369840., 372160., 376480., 378816., 381152., 383488.,
      387888., 390240., 392592., 394944., 399424., 401792., 404160., 406528.,
      259084., 260824., 262564., 264304., 267448., 269200., 270952., 272704.,
      275908., 277672., 279436., 281200., 284464., 286240., 288016., 289792.,
      185276., 186968., 188660., 190352., 193160., 194864., 196568., 198272.,
      201140., 202856., 204572., 206288., 209216., 210944., 212672., 214400.,
      189548., 191288., 193028., 194768., 197624., 199376., 201128., 202880.,
      205796., 207560., 209324., 211088., 214064., 215840., 217616., 219392.,
      131049., 132354., 133659., 134964., 137034., 138348., 139662., 140976.,
      143091., 144414., 145737., 147060., 149220., 150552., 151884., 153216.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61905.,  62562.,  63219.,  63876.,  65154.,  65820.,  66486.,  67152.,
      68475.,  69150.,  69825.,  70500.,  71868.,  72552.,  73236.,  73920.,
      64245.,  64938.,  65631.,  66324.,  67638.,  68340.,  69042.,  69744.,
      71103.,  71814.,  72525.,  73236.,  74640.,  75360.,  76080.,  76800.,
      66585.,  67314.,  68043.,  68772.,  70122.,  70860.,  71598.,  72336.,
      73731.,  74478.,  75225.,  75972.,  77412.,  78168.,  78924.,  79680.,
      80625.,  81570.,  82515.,  83460.,  85026.,  85980.,  86934.,  87888.,
      89499.,  90462.,  91425.,  92388.,  94044.,  95016.,  95988.,  96960.,
      82965.,  83946.,  84927.,  85908.,  87510.,  88500.,  89490.,  90480.,
      92127.,  93126.,  94125.,  95124.,  96816.,  97824.,  98832.,  99840.,
      85305.,  86322.,  87339.,  88356.,  89994.,  91020.,  92046.,  93072.,
      94755.,  95790.,  96825.,  97860.,  99588.,  100632., 101676., 102720.,
      99345.,  100578., 101811., 103044., 104898., 106140., 107382., 108624.,
      110523., 111774., 113025., 114276., 116220., 117480., 118740., 120000.,
      101685., 102954., 104223., 105492., 107382., 108660., 109938., 111216.,
      113151., 114438., 115725., 117012., 118992., 120288., 121584., 122880.,
      104025., 105330., 106635., 107940., 109866., 111180., 112494., 113808.,
      115779., 117102., 118425., 119748., 121764., 123096., 124428., 125760.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9192.,  13461., 8736.,  12987., 18990.,
                                         12303., 7824.,  11409., 7368.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3362., 3440., 3518., 3752., 3830.,
                                         3908., 4142., 4220., 4298.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17928., 18384., 26238., 26922., 17016., 17472., 25290., 25974., 36954.,
      37980., 23922., 24606., 15192., 15648., 22134., 22818., 14280., 14736.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6340., 6724., 6484., 6880., 6628., 7036., 7060., 7504., 7204.,
      7660., 7348., 7816., 7780., 8284., 7924., 8440., 8068., 8596.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35400., 35856., 36312., 36768., 51792., 52476., 53160., 53844., 33576.,
      34032., 34488., 34944., 49896., 50580., 51264., 51948., 72882., 73908.,
      74934., 75960., 47160., 47844., 48528., 49212., 29928., 30384., 30840.,
      31296., 43584., 44268., 44952., 45636., 28104., 28560., 29016., 29472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12296., 12680., 13064., 13448., 12572., 12968., 13364., 13760., 12848.,
      13256., 13664., 14072., 13676., 14120., 14564., 15008., 13952., 14408.,
      14864., 15320., 14228., 14696., 15164., 15632., 15056., 15560., 16064.,
      16568., 15332., 15848., 16364., 16880., 15608., 16136., 16664., 17192.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35484., 36768., 51936., 53844., 33684., 34944., 50076., 51948., 73179.,
      75960., 47376., 49212., 30084., 31296., 43836., 45636., 28284., 29472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12536., 13448., 12824., 13760., 13112., 14072., 13976., 15008., 14264.,
      15320., 14552., 15632., 15416., 16568., 15704., 16880., 15992., 17192.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      70068.,  70968.,  72624.,  73536.,  102522., 103872., 106320., 107688.,
      66468.,  67368.,  68976.,  69888.,  98802.,  100152., 102528., 103896.,
      144333., 146358., 149868., 151920., 93402.,  94752.,  97056.,  98424.,
      59268.,  60168.,  61680.,  62592.,  86322.,  87672.,  89904.,  91272.,
      55668.,  56568.,  58032.,  58944.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24316., 25072., 26128., 26896., 24868., 25648., 26728., 27520., 25420.,
      26224., 27328., 28144., 27076., 27952., 29128., 30016., 27628., 28528.,
      29728., 30640., 28180., 29104., 30328., 31264., 29836., 30832., 32128.,
      33136., 30388., 31408., 32728., 33760., 30940., 31984., 33328., 34384.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      139236., 140136., 141036., 141936., 144336., 145248., 146160., 147072.,
      203694., 205044., 206394., 207744., 211272., 212640., 214008., 215376.,
      132036., 132936., 133836., 134736., 137040., 137952., 138864., 139776.,
      196254., 197604., 198954., 200304., 203688., 205056., 206424., 207792.,
      286641., 288666., 290691., 292716., 297684., 299736., 301788., 303840.,
      185454., 186804., 188154., 189504., 192744., 194112., 195480., 196848.,
      117636., 118536., 119436., 120336., 122448., 123360., 124272., 125184.,
      171294., 172644., 173994., 175344., 178440., 179808., 181176., 182544.,
      110436., 111336., 112236., 113136., 115152., 116064., 116976., 117888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47876., 48632., 49388., 50144., 51488., 52256., 53024., 53792., 48956.,
      49736., 50516., 51296., 52664., 53456., 54248., 55040., 50036., 50840.,
      51644., 52448., 53840., 54656., 55472., 56288., 53276., 54152., 55028.,
      55904., 57368., 58256., 59144., 60032., 54356., 55256., 56156., 57056.,
      58544., 59456., 60368., 61280., 55436., 56360., 57284., 58208., 59720.,
      60656., 61592., 62528., 58676., 59672., 60668., 61664., 63248., 64256.,
      65264., 66272., 59756., 60776., 61796., 62816., 64424., 65456., 66488.,
      67520., 60836., 61880., 62924., 63968., 65600., 66656., 67712., 68768.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      139404., 141936., 144492., 147072., 203982., 207744., 211542., 215376.,
      132252., 134736., 137244., 139776., 196614., 200304., 204030., 207792.,
      287235., 292716., 298251., 303840., 185886., 189504., 193158., 196848.,
      117948., 120336., 122748., 125184., 171798., 175344., 178926., 182544.,
      110796., 113136., 115500., 117888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48356., 50144., 51956., 53792., 49460., 51296., 53156., 55040., 50564.,
      52448., 54356., 56288., 53876., 55904., 57956., 60032., 54980., 57056.,
      59156., 61280., 56084., 58208., 60356., 62528., 59396., 61664., 63956.,
      66272., 60500., 62816., 65156., 67520., 61604., 63968., 66356., 68768.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      277020., 278808., 282072., 283872., 287172., 288984., 292320., 294144.,
      405282., 407964., 412788., 415488., 420366., 423084., 428016., 430752.,
      262716., 264504., 267672., 269472., 272676., 274488., 277728., 279552.,
      390546., 393228., 397908., 400608., 405342., 408060., 412848., 415584.,
      570447., 574470., 581382., 585432., 592425., 596502., 603576., 607680.,
      369090., 371772., 376308., 379008., 383598., 386316., 390960., 393696.,
      234108., 235896., 238872., 240672., 243684., 245496., 248544., 250368.,
      340914., 343596., 347988., 350688., 355134., 357852., 362352., 365088.,
      219804., 221592., 224472., 226272., 229188., 231000., 233952., 235776.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      95212.,  96712.,  98776.,  100288., 102388., 103912., 106048., 107584.,
      97372.,  98920.,  101032., 102592., 104740., 106312., 108496., 110080.,
      99532.,  101128., 103288., 104896., 107092., 108712., 110944., 112576.,
      106012., 107752., 110056., 111808., 114148., 115912., 118288., 120064.,
      108172., 109960., 112312., 114112., 116500., 118312., 120736., 122560.,
      110332., 112168., 114568., 116416., 118852., 120712., 123184., 125056.,
      116812., 118792., 121336., 123328., 125908., 127912., 130528., 132544.,
      118972., 121000., 123592., 125632., 128260., 130312., 132976., 135040.,
      121132., 123208., 125848., 127936., 130612., 132712., 135424., 137536.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      552252.,  554040.,  555828.,  557616.,  562344.,  564144.,  565944.,
      567744.,  572532.,  574344.,  576156.,  577968.,  582816.,  584640.,
      586464.,  588288.,  807882.,  810564.,  813246.,  815928.,  822876.,
      825576.,  828276.,  830976.,  838014.,  840732.,  843450.,  846168.,
      853296.,  856032.,  858768.,  861504.,  523644.,  525432.,  527220.,
      529008.,  533544.,  535344.,  537144.,  538944.,  543540.,  545352.,
      547164.,  548976.,  553632.,  555456.,  557280.,  559104.,  778410.,
      781092.,  783774.,  786456.,  793116.,  795816.,  798516.,  801216.,
      807966.,  810684.,  813402.,  816120.,  822960.,  825696.,  828432.,
      831168.,  1136871., 1140894., 1144917., 1148940., 1158714., 1162764.,
      1166814., 1170864., 1180773., 1184850., 1188927., 1193004., 1203048.,
      1207152., 1211256., 1215360., 735498.,  738180.,  740862.,  743544.,
      749916.,  752616.,  755316.,  758016.,  764478.,  767196.,  769914.,
      772632.,  779184.,  781920.,  784656.,  787392.,  466428.,  468216.,
      470004.,  471792.,  475944.,  477744.,  479544.,  481344.,  485556.,
      487368.,  489180.,  490992.,  495264.,  497088.,  498912.,  500736.,
      679146.,  681828.,  684510.,  687192.,  693276.,  695976.,  698676.,
      701376.,  707550.,  710268.,  712986.,  715704.,  721968.,  724704.,
      727440.,  730176.,  437820.,  439608.,  441396.,  443184.,  447144.,
      448944.,  450744.,  452544.,  456564.,  458376.,  460188.,  462000.,
      466080.,  467904.,  469728.,  471552.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188924., 190424., 191924., 193424., 196040., 197552., 199064., 200576.,
      203252., 204776., 206300., 207824., 210560., 212096., 213632., 215168.,
      193196., 194744., 196292., 197840., 200504., 202064., 203624., 205184.,
      207908., 209480., 211052., 212624., 215408., 216992., 218576., 220160.,
      197468., 199064., 200660., 202256., 204968., 206576., 208184., 209792.,
      212564., 214184., 215804., 217424., 220256., 221888., 223520., 225152.,
      210284., 212024., 213764., 215504., 218360., 220112., 221864., 223616.,
      226532., 228296., 230060., 231824., 234800., 236576., 238352., 240128.,
      214556., 216344., 218132., 219920., 222824., 224624., 226424., 228224.,
      231188., 233000., 234812., 236624., 239648., 241472., 243296., 245120.,
      218828., 220664., 222500., 224336., 227288., 229136., 230984., 232832.,
      235844., 237704., 239564., 241424., 244496., 246368., 248240., 250112.,
      231644., 233624., 235604., 237584., 240680., 242672., 244664., 246656.,
      249812., 251816., 253820., 255824., 259040., 261056., 263072., 265088.,
      235916., 237944., 239972., 242000., 245144., 247184., 249224., 251264.,
      254468., 256520., 258572., 260624., 263888., 265952., 268016., 270080.,
      240188., 242264., 244340., 246416., 249608., 251696., 253784., 255872.,
      259124., 261224., 263324., 265424., 268736., 270848., 272960., 275072.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15981., 16260., 10554., 22554., 22932.,
                                         14859., 13551., 13776., 8898.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4002., 4080., 4158., 4470., 4548.,
                                         4626., 4938., 5016., 5094.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31152., 31962., 31692., 32520., 20556., 21108., 43893., 45108., 44622.,
      45864., 28890., 29718., 26292., 27102., 26724., 27552., 17244., 17796.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7548., 8004., 7692., 8160., 7836., 8316., 8412.,  8940., 8556.,
      9096., 8700., 9252., 9276., 9876., 9420., 10032., 9564., 10188.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61494., 62304., 63114., 63924., 62556., 63384., 64212., 65040., 40560.,
      41112., 41664., 42216., 86571., 87786., 89001., 90216., 88002., 89244.,
      90486., 91728., 56952., 57780., 58608., 59436., 51774., 52584., 53394.,
      54204., 52620., 53448., 54276., 55104., 33936., 34488., 35040., 35592.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14640., 15096., 15552., 16008., 14916., 15384., 15852., 16320., 15192.,
      15672., 16152., 16632., 16296., 16824., 17352., 17880., 16572., 17112.,
      17652., 18192., 16848., 17400., 17952., 18504., 17952., 18552., 19152.,
      19752., 18228., 18840., 19452., 20064., 18504., 19128., 19752., 20376.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61764., 63924., 62844., 65040., 40764., 42216., 87057., 90216., 88515.,
      91728., 57312., 59436., 52152., 54204., 53016., 55104., 34212., 35592.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14952., 16008., 15240., 16320., 15528., 16632., 16680., 17880., 16968.,
      18192., 17256., 18504., 18408., 19752., 18696., 20064., 18984., 20376.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121926., 123528., 126228., 127848., 124050., 125688., 128424., 130080.,
      80436.,  81528.,  83328.,  84432.,  171711., 174114., 178002., 180432.,
      174573., 177030., 180972., 183456., 112986., 114624., 117216., 118872.,
      102702., 104304., 106788., 108408., 104394., 106032., 108552., 110208.,
      67332.,  68424.,  70080.,  71184.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29004., 29904., 31104., 32016., 29556., 30480., 31704., 32640., 30108.,
      31056., 32304., 33264., 32316., 33360., 34704., 35760., 32868., 33936.,
      35304., 36384., 33420., 34512., 35904., 37008., 35628., 36816., 38304.,
      39504., 36180., 37392., 38904., 40128., 36732., 37968., 39504., 40752.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      242250., 243852., 245454., 247056., 250836., 252456., 254076., 255696.,
      246462., 248100., 249738., 251376., 255192., 256848., 258504., 260160.,
      159780., 160872., 161964., 163056., 165552., 166656., 167760., 168864.,
      341019., 343422., 345825., 348228., 353574., 356004., 358434., 360864.,
      346689., 349146., 351603., 354060., 359460., 361944., 364428., 366912.,
      224334., 225972., 227610., 229248., 232776., 234432., 236088., 237744.,
      203802., 205404., 207006., 208608., 211956., 213576., 215196., 216816.,
      207150., 208788., 210426., 212064., 215448., 217104., 218760., 220416.,
      133572., 134664., 135756., 136848., 139056., 140160., 141264., 142368.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57108., 58008., 58908., 59808., 61296., 62208., 63120., 64032., 58188.,
      59112., 60036., 60960., 62472., 63408., 64344., 65280., 59268., 60216.,
      61164., 62112., 63648., 64608., 65568., 66528., 63588., 64632., 65676.,
      66720., 68352., 69408., 70464., 71520., 64668., 65736., 66804., 67872.,
      69528., 70608., 71688., 72768., 65748., 66840., 67932., 69024., 70704.,
      71808., 72912., 74016., 70068., 71256., 72444., 73632., 75408., 76608.,
      77808., 79008., 71148., 72360., 73572., 74784., 76584., 77808., 79032.,
      80256., 72228., 73464., 74700., 75936., 77760., 79008., 80256., 81504.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      242790., 247056., 251358., 255696., 247038., 251376., 255750., 260160.,
      160188., 163056., 165948., 168864., 341991., 348228., 354519., 360864.,
      347715., 354060., 360459., 366912., 225054., 229248., 233478., 237744.,
      204558., 208608., 212694., 216816., 207942., 212064., 216222., 220416.,
      134124., 136848., 139596., 142368.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57732., 59808., 61908., 64032., 58836., 60960., 63108., 65280., 59940.,
      62112., 64308., 66528., 64356., 66720., 69108., 71520., 65460., 67872.,
      70308., 72768., 66564., 69024., 71508., 74016., 70980., 73632., 76308.,
      79008., 72084., 74784., 77508., 80256., 73188., 75936., 78708., 81504.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      482394., 485580., 490908., 494112., 499494., 502716., 508152., 511392.,
      490818., 494076., 499476., 502752., 508206., 511500., 517008., 520320.,
      318204., 320376., 323928., 326112., 329700., 331896., 335520., 337728.,
      679203., 683982., 691650., 696456., 704205., 709038., 716868., 721728.,
      690543., 695430., 703206., 708120., 715977., 720918., 728856., 733824.,
      446850., 450108., 455220., 458496., 463662., 466956., 472176., 475488.,
      405930., 409116., 414012., 417216., 422166., 425388., 430392., 433632.,
      412626., 415884., 420852., 424128., 429150., 432444., 437520., 440832.,
      266076., 268248., 271512., 273696., 276996., 279192., 282528., 284736.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113676., 115464., 117816., 119616., 122004., 123816., 126240., 128064.,
      115836., 117672., 120072., 121920., 124356., 126216., 128688., 130560.,
      117996., 119880., 122328., 124224., 126708., 128616., 131136., 133056.,
      126636., 128712., 131352., 133440., 136116., 138216., 140928., 143040.,
      128796., 130920., 133608., 135744., 138468., 140616., 143376., 145536.,
      130956., 133128., 135864., 138048., 140820., 143016., 145824., 148032.,
      139596., 141960., 144888., 147264., 150228., 152616., 155616., 158016.,
      141756., 144168., 147144., 149568., 152580., 155016., 158064., 160512.,
      143916., 146376., 149400., 151872., 154932., 157416., 160512., 163008.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      961602.,  964788.,  967974.,  971160.,  978612.,  981816.,  985020.,
      988224.,  995766.,  998988.,  1002210., 1005432., 1013064., 1016304.,
      1019544., 1022784., 978378.,  981636.,  984894.,  988152.,  995676.,
      998952.,  1002228., 1005504., 1013118., 1016412., 1019706., 1023000.,
      1030704., 1034016., 1037328., 1040640., 634236.,  636408.,  638580.,
      640752.,  645672.,  647856.,  650040.,  652224.,  657204.,  659400.,
      661596.,  663792.,  668832.,  671040.,  673248.,  675456.,  1353627.,
      1358406., 1363185., 1367964., 1378494., 1383300., 1388106., 1392912.,
      1403577., 1408410., 1413243., 1418076., 1428876., 1433736., 1438596.,
      1443456., 1376199., 1381086., 1385973., 1390860., 1401498., 1406412.,
      1411326., 1416240., 1427013., 1431954., 1436895., 1441836., 1452744.,
      1457712., 1462680., 1467648., 890442.,  893700.,  896958.,  900216.,
      907164.,  910440.,  913716.,  916992.,  924030.,  927324.,  930618.,
      933912.,  941040.,  944352.,  947664.,  950976.,  808674.,  811860.,
      815046.,  818232.,  824820.,  828024.,  831228.,  834432.,  841110.,
      844332.,  847554.,  850776.,  857544.,  860784.,  864024.,  867264.,
      821994.,  825252.,  828510.,  831768.,  838428.,  841704.,  844980.,
      848256.,  855006.,  858300.,  861594.,  864888.,  871728.,  875040.,
      878352.,  881664.,  529980.,  532152.,  534324.,  536496.,  540840.,
      543024.,  545208.,  547392.,  551796.,  553992.,  556188.,  558384.,
      562848.,  565056.,  567264.,  569472.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      225564., 227352., 229140., 230928., 233832., 235632., 237432., 239232.,
      242196., 244008., 245820., 247632., 250656., 252480., 254304., 256128.,
      229836., 231672., 233508., 235344., 238296., 240144., 241992., 243840.,
      246852., 248712., 250572., 252432., 255504., 257376., 259248., 261120.,
      234108., 235992., 237876., 239760., 242760., 244656., 246552., 248448.,
      251508., 253416., 255324., 257232., 260352., 262272., 264192., 266112.,
      251196., 253272., 255348., 257424., 260616., 262704., 264792., 266880.,
      270132., 272232., 274332., 276432., 279744., 281856., 283968., 286080.,
      255468., 257592., 259716., 261840., 265080., 267216., 269352., 271488.,
      274788., 276936., 279084., 281232., 284592., 286752., 288912., 291072.,
      259740., 261912., 264084., 266256., 269544., 271728., 273912., 276096.,
      279444., 281640., 283836., 286032., 289440., 291648., 293856., 296064.,
      276828., 279192., 281556., 283920., 287400., 289776., 292152., 294528.,
      298068., 300456., 302844., 305232., 308832., 311232., 313632., 316032.,
      281100., 283512., 285924., 288336., 291864., 294288., 296712., 299136.,
      302724., 305160., 307596., 310032., 313680., 316128., 318576., 321024.,
      285372., 287832., 290292., 292752., 296328., 298800., 301272., 303744.,
      307380., 309864., 312348., 314832., 318528., 321024., 323520., 326016.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37644., 38136., 28032., 53106., 53772.,
                                         39474., 31884., 32280., 23640.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11841., 12012., 12183., 13209., 13380.,
                                         13551., 14577., 14748., 14919.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73848.,  75288.,  74808.,  76272.,  54966., 56064.,
      104052., 106212., 105348., 107544., 77301., 78948.,
      62328.,  63768.,  63096.,  64560.,  46182., 47280.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22764., 23682., 23088., 24024., 23412., 24366., 25356., 26418., 25680.,
      26760., 26004., 27102., 27948., 29154., 28272., 29496., 28596., 29838.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146256., 147696., 149136., 150576., 148152., 149616., 151080., 152544.,
      108834., 109932., 111030., 112128., 205944., 208104., 210264., 212424.,
      208500., 210696., 212892., 215088., 152955., 154602., 156249., 157896.,
      123216., 124656., 126096., 127536., 124728., 126192., 127656., 129120.,
      91266.,  92364.,  93462.,  94560.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44610., 45528., 46446., 47364., 45240., 46176., 47112., 48048., 45870.,
      46824., 47778., 48732., 49650., 50712., 51774., 52836., 50280., 51360.,
      52440., 53520., 50910., 52008., 53106., 54204., 54690., 55896., 57102.,
      58308., 55320., 56544., 57768., 58992., 55950., 57192., 58434., 59676.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146736., 150576., 148656., 152544., 109230., 112128.,
      206808., 212424., 209400., 215088., 153657., 157896.,
      123888., 127536., 125424., 129120., 91806.,  94560.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45204., 47364., 45852., 48048., 46500., 48732., 50388., 52836., 51036.,
      53520., 51684., 54204., 55572., 58308., 56220., 58992., 56868., 59676.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      290616., 293472., 298272., 301152., 294408., 297312., 302160., 305088.,
      216282., 218460., 222060., 224256., 409332., 413616., 420528., 424848.,
      414444., 418800., 425784., 430176., 304047., 307314., 312498., 315792.,
      244920., 247776., 252192., 255072., 247944., 250848., 255312., 258240.,
      181434., 183612., 186924., 189120.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      88590.,  90408.,  92892.,  94728.,  89850.,  91704.,  94224.,  96096.,
      91110.,  93000.,  95556.,  97464.,  98670.,  100776., 103548., 105672.,
      99930.,  102072., 104880., 107040., 101190., 103368., 106212., 108408.,
      108750., 111144., 114204., 116616., 110010., 112440., 115536., 117984.,
      111270., 113736., 116868., 119352.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      578376., 581232., 584088., 586944., 593664., 596544., 599424., 602304.,
      585912., 588816., 591720., 594624., 601392., 604320., 607248., 610176.,
      430386., 432564., 434742., 436920., 441924., 444120., 446316., 448512.,
      814380., 818664., 822948., 827232., 836736., 841056., 845376., 849696.,
      824532., 828888., 833244., 837600., 847176., 851568., 855960., 860352.,
      604827., 608094., 611361., 614628., 621702., 624996., 628290., 631584.,
      486984., 489840., 492696., 495552., 501504., 504384., 507264., 510144.,
      492984., 495888., 498792., 501696., 507696., 510624., 513552., 516480.,
      360690., 362868., 365046., 367224., 371652., 373848., 376044., 378240.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      175362., 177180., 178998., 180816., 183948., 185784., 187620., 189456.,
      177846., 179700., 181554., 183408., 186576., 188448., 190320., 192192.,
      180330., 182220., 184110., 186000., 189204., 191112., 193020., 194928.,
      195234., 197340., 199446., 201552., 204972., 207096., 209220., 211344.,
      197718., 199860., 202002., 204144., 207600., 209760., 211920., 214080.,
      200202., 202380., 204558., 206736., 210228., 212424., 214620., 216816.,
      215106., 217500., 219894., 222288., 225996., 228408., 230820., 233232.,
      217590., 220020., 222450., 224880., 228624., 231072., 233520., 235968.,
      220074., 222540., 225006., 227472., 231252., 233736., 236220., 238704.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      579336., 586944., 594600., 602304., 586920., 594624., 602376., 610176.,
      431178., 436920., 442698., 448512., 816108., 827232., 838428., 849696.,
      826332., 837600., 848940., 860352., 606231., 614628., 623079., 631584.,
      488328., 495552., 502824., 510144., 494376., 501696., 509064., 516480.,
      361770., 367224., 372714., 378240.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      176550., 180816., 185118., 189456., 179070., 183408., 187782., 192192.,
      181590., 186000., 190446., 194928., 196710., 201552., 206430., 211344.,
      199230., 204144., 209094., 214080., 201750., 206736., 211758., 216816.,
      216870., 222288., 227742., 233232., 219390., 224880., 230406., 235968.,
      221910., 227472., 233070., 238704.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1152984., 1158672., 1168176., 1173888., 1183464., 1189200., 1198848.,
      1204608., 1168056., 1173840., 1183440., 1189248., 1198920., 1204752.,
      1214496., 1220352., 858018.,  862356.,  869484.,  873840.,  881022.,
      885396.,  892632.,  897024.,  1623684., 1632216., 1645896., 1654464.,
      1668252., 1676856., 1690752., 1699392., 1643988., 1652664., 1666488.,
      1675200., 1689132., 1697880., 1711920., 1720704., 1205955., 1212462.,
      1222722., 1229256., 1239597., 1246158., 1256580., 1263168., 970968.,
      976656.,  985392.,  991104.,  999912.,  1005648., 1014528., 1020288.,
      982968.,  988752.,  997584.,  1003392., 1012296., 1018128., 1027104.,
      1032960., 719202.,  723540.,  730092.,  734448.,  741054.,  745428.,
      752088.,  756480.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      349482., 353100., 357996., 361632., 366582., 370236., 375240., 378912.,
      354450., 358140., 363108., 366816., 371838., 375564., 380640., 384384.,
      359418., 363180., 368220., 372000., 377094., 380892., 386040., 389856.,
      389226., 393420., 398892., 403104., 408630., 412860., 418440., 422688.,
      394194., 398460., 404004., 408288., 413886., 418188., 423840., 428160.,
      399162., 403500., 409116., 413472., 419142., 423516., 429240., 433632.,
      428970., 433740., 439788., 444576., 450678., 455484., 461640., 466464.,
      433938., 438780., 444900., 449760., 455934., 460812., 467040., 471936.,
      438906., 443820., 450012., 454944., 461190., 466140., 472440., 477408.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2300280., 2305968., 2311656., 2317344., 2330640., 2336352., 2342064.,
      2347776., 2361192., 2366928., 2372664., 2378400., 2391936., 2397696.,
      2403456., 2409216., 2330328., 2336112., 2341896., 2347680., 2361072.,
      2366880., 2372688., 2378496., 2392008., 2397840., 2403672., 2409504.,
      2423136., 2428992., 2434848., 2440704., 1711698., 1716036., 1720374.,
      1724712., 1734612., 1738968., 1743324., 1747680., 1757670., 1762044.,
      1766418., 1770792., 1780872., 1785264., 1789656., 1794048., 3238836.,
      3247368., 3255900., 3264432., 3283224., 3291792., 3300360., 3308928.,
      3327900., 3336504., 3345108., 3353712., 3372864., 3381504., 3390144.,
      3398784., 3279300., 3287976., 3296652., 3305328., 3324264., 3332976.,
      3341688., 3350400., 3369516., 3378264., 3387012., 3395760., 3415056.,
      3423840., 3432624., 3441408., 2405403., 2411910., 2418417., 2424924.,
      2438910., 2445444., 2451978., 2458512., 2472633., 2479194., 2485755.,
      2492316., 2506572., 2513160., 2519748., 2526336., 1936248., 1941936.,
      1947624., 1953312., 1965072., 1970784., 1976496., 1982208., 1994088.,
      1999824., 2005560., 2011296., 2023296., 2029056., 2034816., 2040576.,
      1960152., 1965936., 1971720., 1977504., 1989360., 1995168., 2000976.,
      2006784., 2018760., 2024592., 2030424., 2036256., 2048352., 2054208.,
      2060064., 2065920., 1434066., 1438404., 1442742., 1447080., 1455828.,
      1460184., 1464540., 1468896., 1477734., 1482108., 1486482., 1490856.,
      1499784., 1504176., 1508568., 1512960.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x5x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      695346., 698964., 702582., 706200., 712356., 715992., 719628., 723264.,
      729510., 733164., 736818., 740472., 746808., 750480., 754152., 757824.,
      705210., 708900., 712590., 716280., 722508., 726216., 729924., 733632.,
      739950., 743676., 747402., 751128., 757536., 761280., 765024., 768768.,
      715074., 718836., 722598., 726360., 732660., 736440., 740220., 744000.,
      750390., 754188., 757986., 761784., 768264., 772080., 775896., 779712.,
      774258., 778452., 782646., 786840., 793572., 797784., 801996., 806208.,
      813030., 817260., 821490., 825720., 832632., 836880., 841128., 845376.,
      784122., 788388., 792654., 796920., 803724., 808008., 812292., 816576.,
      823470., 827772., 832074., 836376., 843360., 847680., 852000., 856320.,
      793986., 798324., 802662., 807000., 813876., 818232., 822588., 826944.,
      833910., 838284., 842658., 847032., 854088., 858480., 862872., 867264.,
      853170., 857940., 862710., 867480., 874788., 879576., 884364., 889152.,
      896550., 901356., 906162., 910968., 918456., 923280., 928104., 932928.,
      863034., 867876., 872718., 877560., 884940., 889800., 894660., 899520.,
      906990., 911868., 916746., 921624., 929184., 934080., 938976., 943872.,
      872898., 877812., 882726., 887640., 895092., 900024., 904956., 909888.,
      917430., 922380., 927330., 932280., 939912., 944880., 949848., 954816.};
  const std::array<int, 4> in_shape = {{3, 5, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14832., 21690., 14058., 16137., 23580.,
                                         15273., 9744.,  14199., 9168.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3912., 3990., 4068., 4302., 4380.,
                                         4458., 4692., 4770., 4848.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28890., 29664., 42219., 43380., 27342., 28116., 31410., 32274., 45864.,
      47160., 29682., 30546., 18912., 19488., 27534., 28398., 17760., 18336.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7380., 7824., 7524., 7980., 7668., 8136., 8100., 8604., 8244.,
      8760., 8388., 8916., 8820., 9384., 8964., 9540., 9108., 9696.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57006., 57780., 58554., 59328., 83277., 84438., 85599., 86760., 53910.,
      54684., 55458., 56232., 61956., 62820., 63684., 64548., 90432., 91728.,
      93024., 94320., 58500., 59364., 60228., 61092., 37248., 37824., 38400.,
      38976., 54204., 55068., 55932., 56796., 34944., 35520., 36096., 36672.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14316., 14760., 15204., 15648., 14592., 15048., 15504., 15960., 14868.,
      15336., 15804., 16272., 15696., 16200., 16704., 17208., 15972., 16488.,
      17004., 17520., 16248., 16776., 17304., 17832., 17076., 17640., 18204.,
      18768., 17352., 17928., 18504., 19080., 17628., 18216., 18804., 19392.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57276., 59328., 83709., 86760., 54216., 56232., 62316., 64548., 90999.,
      94320., 58896., 61092., 37524., 38976., 54636., 56796., 35244., 36672.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14616., 15648., 14904., 15960., 15192., 16272., 16056., 17208., 16344.,
      17520., 16632., 17832., 17496., 18768., 17784., 19080., 18072., 19392.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113022., 114552., 117108., 118656., 165123., 167418., 171198., 173520.,
      106902., 108432., 110916., 112464., 122922., 124632., 127368., 129096.,
      179433., 181998., 186048., 188640., 116082., 117792., 120456., 122184.,
      73908.,  75048.,  76800.,  77952.,  107562., 109272., 111864., 113592.,
      69348.,  70488.,  72192.,  73344.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28356., 29232., 30408., 31296., 28908., 29808., 31008., 31920., 29460.,
      30384., 31608., 32544., 31116., 32112., 33408., 34416., 31668., 32688.,
      34008., 35040., 32220., 33264., 34608., 35664., 33876., 34992., 36408.,
      37536., 34428., 35568., 37008., 38160., 34980., 36144., 37608., 38784.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224514., 226044., 227574., 229104., 232668., 234216., 235764., 237312.,
      327951., 330246., 332541., 334836., 340074., 342396., 344718., 347040.,
      212274., 213804., 215334., 216864., 220284., 221832., 223380., 224928.,
      244134., 245844., 247554., 249264., 253008., 254736., 256464., 258192.,
      356301., 358866., 361431., 363996., 369504., 372096., 374688., 377280.,
      230454., 232164., 233874., 235584., 239184., 240912., 242640., 244368.,
      146676., 147816., 148956., 150096., 152448., 153600., 154752., 155904.,
      213414., 215124., 216834., 218544., 222000., 223728., 225456., 227184.,
      137556., 138696., 139836., 140976., 143232., 144384., 145536., 146688.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55836., 56712., 57588., 58464., 59928., 60816., 61704., 62592., 56916.,
      57816., 58716., 59616., 61104., 62016., 62928., 63840., 57996., 58920.,
      59844., 60768., 62280., 63216., 64152., 65088., 61236., 62232., 63228.,
      64224., 65808., 66816., 67824., 68832., 62316., 63336., 64356., 65376.,
      66984., 68016., 69048., 70080., 63396., 64440., 65484., 66528., 68160.,
      69216., 70272., 71328., 66636., 67752., 68868., 69984., 71688., 72816.,
      73944., 75072., 67716., 68856., 69996., 71136., 72864., 74016., 75168.,
      76320., 68796., 69960., 71124., 72288., 74040., 75216., 76392., 77568.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      225054., 229104., 233190., 237312., 328815., 334836., 340911., 347040.,
      212886., 216864., 220878., 224928., 244854., 249264., 253710., 258192.,
      357435., 363996., 370611., 377280., 231246., 235584., 239958., 244368.,
      147228., 150096., 152988., 155904., 214278., 218544., 222846., 227184.,
      138156., 140976., 143820., 146688.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56436., 58464., 60516., 62592., 57540., 59616., 61716., 63840., 58644.,
      60768., 62916., 65088., 61956., 64224., 66516., 68832., 63060., 65376.,
      67716., 70080., 64164., 66528., 68916., 71328., 67476., 69984., 72516.,
      75072., 68580., 71136., 73716., 76320., 69684., 72288., 74916., 77568.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      447066., 450108., 455148., 458208., 463302., 466380., 471528., 474624.,
      653067., 657630., 665082., 669672., 677205., 681822., 689436., 694080.,
      422730., 425772., 430668., 433728., 438678., 441756., 446760., 449856.,
      486306., 489708., 495108., 498528., 503982., 507420., 512928., 516384.,
      709767., 714870., 722862., 727992., 736065., 741222., 749376., 754560.,
      459090., 462492., 467748., 471168., 476478., 479916., 485280., 488736.,
      292188., 294456., 297912., 300192., 303684., 305976., 309504., 311808.,
      425154., 428556., 433668., 437088., 442254., 445692., 450912., 454368.,
      274044., 276312., 279672., 281952., 285348., 287640., 291072., 293376.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111132., 112872., 115176., 116928., 119268., 121032., 123408., 125184.,
      113292., 115080., 117432., 119232., 121620., 123432., 125856., 127680.,
      115452., 117288., 119688., 121536., 123972., 125832., 128304., 130176.,
      121932., 123912., 126456., 128448., 131028., 133032., 135648., 137664.,
      124092., 126120., 128712., 130752., 133380., 135432., 138096., 140160.,
      126252., 128328., 130968., 133056., 135732., 137832., 140544., 142656.,
      132732., 134952., 137736., 139968., 142788., 145032., 147888., 150144.,
      134892., 137160., 139992., 142272., 145140., 147432., 150336., 152640.,
      137052., 139368., 142248., 144576., 147492., 149832., 152784., 155136.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      891090.,  894132.,  897174.,  900216.,  907236.,  910296.,  913356.,
      916416.,  923526.,  926604.,  929682.,  932760.,  939960.,  943056.,
      946152.,  949248.,  1301571., 1306134., 1310697., 1315260., 1325574.,
      1330164., 1334754., 1339344., 1349793., 1354410., 1359027., 1363644.,
      1374228., 1378872., 1383516., 1388160., 842418.,  845460.,  848502.,
      851544.,  858276.,  861336.,  864396.,  867456.,  874278.,  877356.,
      880434.,  883512.,  890424.,  893520.,  896616.,  899712.,  969210.,
      972612.,  976014.,  979416.,  986796.,  990216.,  993636.,  997056.,
      1004526., 1007964., 1011402., 1014840., 1022400., 1025856., 1029312.,
      1032768., 1414431., 1419534., 1424637., 1429740., 1440594., 1445724.,
      1450854., 1455984., 1466973., 1472130., 1477287., 1482444., 1493568.,
      1498752., 1503936., 1509120., 914778.,  918180.,  921582.,  924984.,
      932076.,  935496.,  938916.,  942336.,  949518.,  952956.,  956394.,
      959832.,  967104.,  970560.,  974016.,  977472.,  582108.,  584376.,
      586644.,  588912.,  593544.,  595824.,  598104.,  600384.,  605076.,
      607368.,  609660.,  611952.,  616704.,  619008.,  621312.,  623616.,
      846906.,  850308.,  853710.,  857112.,  863916.,  867336.,  870756.,
      874176.,  881070.,  884508.,  887946.,  891384.,  898368.,  901824.,
      905280.,  908736.,  545820.,  548088.,  550356.,  552624.,  557064.,
      559344.,  561624.,  563904.,  568404.,  570696.,  572988.,  575280.,
      579840.,  582144.,  584448.,  586752.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      220524., 222264., 224004., 225744., 228600., 230352., 232104., 233856.,
      236772., 238536., 240300., 242064., 245040., 246816., 248592., 250368.,
      224796., 226584., 228372., 230160., 233064., 234864., 236664., 238464.,
      241428., 243240., 245052., 246864., 249888., 251712., 253536., 255360.,
      229068., 230904., 232740., 234576., 237528., 239376., 241224., 243072.,
      246084., 247944., 249804., 251664., 254736., 256608., 258480., 260352.,
      241884., 243864., 245844., 247824., 250920., 252912., 254904., 256896.,
      260052., 262056., 264060., 266064., 269280., 271296., 273312., 275328.,
      246156., 248184., 250212., 252240., 255384., 257424., 259464., 261504.,
      264708., 266760., 268812., 270864., 274128., 276192., 278256., 280320.,
      250428., 252504., 254580., 256656., 259848., 261936., 264024., 266112.,
      269364., 271464., 273564., 275664., 278976., 281088., 283200., 285312.,
      263244., 265464., 267684., 269904., 273240., 275472., 277704., 279936.,
      283332., 285576., 287820., 290064., 293520., 295776., 298032., 300288.,
      267516., 269784., 272052., 274320., 277704., 279984., 282264., 284544.,
      287988., 290280., 292572., 294864., 298368., 300672., 302976., 305280.,
      271788., 274104., 276420., 278736., 282168., 284496., 286824., 289152.,
      292644., 294984., 297324., 299664., 303216., 305568., 307920., 310272.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25794., 26172., 16965., 28062., 28440.,
                                         18423., 16899., 17124., 11058.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4662., 4740., 4818., 5130., 5208.,
                                         5286., 5598., 5676., 5754.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50211., 51588., 50940., 52344., 32994., 33930., 54585., 56124., 55314.,
      56880., 35802., 36846., 32772., 33798., 33204., 34248., 21420., 22116.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8796.,  9324., 8940.,  9480.,  9084.,  9636.,  9660.,  10260., 9804.,
      10416., 9948., 10572., 10524., 11196., 10668., 11352., 10812., 11508.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      99045.,  100422., 101799., 103176., 100476., 101880., 103284., 104688.,
      65052.,  65988.,  66924.,  67860.,  107631., 109170., 110709., 112248.,
      109062., 110628., 112194., 113760., 70560.,  71604.,  72648.,  73692.,
      64518.,  65544.,  66570.,  67596.,  65364.,  66408.,  67452.,  68496.,
      42144.,  42840.,  43536.,  44232.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17064., 17592., 18120., 18648., 17340., 17880., 18420., 18960., 17616.,
      18168., 18720., 19272., 18720., 19320., 19920., 20520., 18996., 19608.,
      20220., 20832., 19272., 19896., 20520., 21144., 20376., 21048., 21720.,
      22392., 20652., 21336., 22020., 22704., 20928., 21624., 22320., 23016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      99693.,  103176., 101151., 104688., 65520., 67860.,
      108441., 112248., 109899., 113760., 71136., 73692.,
      65112.,  67596.,  65976.,  68496.,  42564., 44232.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17448., 18648., 17736., 18960., 18024., 19272., 19176., 20520., 19464.,
      20832., 19752., 21144., 20904., 22392., 21192., 22704., 21480., 23016.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      196659., 199386., 203598., 206352., 199521., 202302., 206568., 209376.,
      129186., 131040., 133848., 135720., 213831., 216882., 221418., 224496.,
      216693., 219798., 224388., 227520., 140202., 142272., 145296., 147384.,
      128190., 130224., 133140., 135192., 129882., 131952., 134904., 136992.,
      83748.,  85128.,  87072.,  88464.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33852., 34896., 36240., 37296., 34404., 35472., 36840., 37920., 34956.,
      36048., 37440., 38544., 37164., 38352., 39840., 41040., 37716., 38928.,
      40440., 41664., 38268., 39504., 41040., 42288., 40476., 41808., 43440.,
      44784., 41028., 42384., 44040., 45408., 41580., 42960., 44640., 46032.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      390591., 393318., 396045., 398772., 404442., 407196., 409950., 412704.,
      396261., 399042., 401823., 404604., 410328., 413136., 415944., 418752.,
      256518., 258372., 260226., 262080., 265824., 267696., 269568., 271440.,
      424611., 427662., 430713., 433764., 439758., 442836., 445914., 448992.,
      430281., 433386., 436491., 439596., 445644., 448776., 451908., 455040.,
      278334., 280404., 282474., 284544., 288504., 290592., 292680., 294768.,
      254346., 256380., 258414., 260448., 264228., 266280., 268332., 270384.,
      257694., 259764., 261834., 263904., 267720., 269808., 271896., 273984.,
      166116., 167496., 168876., 170256., 172752., 174144., 175536., 176928.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      66660., 67704., 68748., 69792., 71424., 72480., 73536., 74592., 67740.,
      68808., 69876., 70944., 72600., 73680., 74760., 75840., 68820., 69912.,
      71004., 72096., 73776., 74880., 75984., 77088., 73140., 74328., 75516.,
      76704., 78480., 79680., 80880., 82080., 74220., 75432., 76644., 77856.,
      79656., 80880., 82104., 83328., 75300., 76536., 77772., 79008., 80832.,
      82080., 83328., 84576., 79620., 80952., 82284., 83616., 85536., 86880.,
      88224., 89568., 80700., 82056., 83412., 84768., 86712., 88080., 89448.,
      90816., 81780., 83160., 84540., 85920., 87888., 89280., 90672., 92064.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      391887., 398772., 405711., 412704., 397611., 404604., 411651., 418752.,
      257454., 262080., 266742., 271440., 426231., 433764., 441351., 448992.,
      431955., 439596., 447291., 455040., 279486., 284544., 289638., 294768.,
      255534., 260448., 265398., 270384., 258918., 263904., 268926., 273984.,
      166956., 170256., 173580., 176928.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67428., 69792., 72180., 74592., 68532., 70944., 73380., 75840., 69636.,
      72096., 74580., 77088., 74052., 76704., 79380., 82080., 75156., 77856.,
      80580., 83328., 76260., 79008., 81780., 84576., 80676., 83616., 86580.,
      89568., 81780., 84768., 87780., 90816., 82884., 85920., 88980., 92064.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      778347., 783774., 792090., 797544., 805941., 811422., 819900., 825408.,
      789687., 795222., 803646., 809208., 817713., 823302., 831888., 837504.,
      511218., 514908., 520452., 524160., 529758., 533484., 539136., 542880.,
      846387., 852462., 861426., 867528., 876573., 882702., 891828., 897984.,
      857727., 863910., 872982., 879192., 888345., 894582., 903816., 910080.,
      554850., 558972., 564948., 569088., 575118., 579276., 585360., 589536.,
      507018., 511068., 516828., 520896., 526710., 530796., 536664., 540768.,
      513714., 517836., 523668., 527808., 533694., 537852., 543792., 547968.,
      331164., 333912., 337752., 340512., 344388., 347160., 351072., 353856.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      132780., 134856., 137496., 139584., 142260., 144360., 147072., 149184.,
      134940., 137064., 139752., 141888., 144612., 146760., 149520., 151680.,
      137100., 139272., 142008., 144192., 146964., 149160., 151968., 154176.,
      145740., 148104., 151032., 153408., 156372., 158760., 161760., 164160.,
      147900., 150312., 153288., 155712., 158724., 161160., 164208., 166656.,
      150060., 152520., 155544., 158016., 161076., 163560., 166656., 169152.,
      158700., 161352., 164568., 167232., 170484., 173160., 176448., 179136.,
      160860., 163560., 166824., 169536., 172836., 175560., 178896., 181632.,
      163020., 165768., 169080., 171840., 175188., 177960., 181344., 184128.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1551267., 1556694., 1562121., 1567548., 1578726., 1584180., 1589634.,
      1595088., 1606401., 1611882., 1617363., 1622844., 1634292., 1639800.,
      1645308., 1650816., 1573839., 1579374., 1584909., 1590444., 1601730.,
      1607292., 1612854., 1618416., 1629837., 1635426., 1641015., 1646604.,
      1658160., 1663776., 1669392., 1675008., 1018746., 1022436., 1026126.,
      1029816., 1037196., 1040904., 1044612., 1048320., 1055790., 1059516.,
      1063242., 1066968., 1074528., 1078272., 1082016., 1085760., 1686699.,
      1692774., 1698849., 1704924., 1716750., 1722852., 1728954., 1735056.,
      1747017., 1753146., 1759275., 1765404., 1777500., 1783656., 1789812.,
      1795968., 1709271., 1715454., 1721637., 1727820., 1739754., 1745964.,
      1752174., 1758384., 1770453., 1776690., 1782927., 1789164., 1801368.,
      1807632., 1813896., 1820160., 1105578., 1109700., 1113822., 1117944.,
      1125756., 1129896., 1134036., 1138176., 1146078., 1150236., 1154394.,
      1158552., 1166544., 1170720., 1174896., 1179072., 1009986., 1014036.,
      1018086., 1022136., 1029588., 1033656., 1037724., 1041792., 1049334.,
      1053420., 1057506., 1061592., 1069224., 1073328., 1077432., 1081536.,
      1023306., 1027428., 1031550., 1035672., 1043196., 1047336., 1051476.,
      1055616., 1063230., 1067388., 1071546., 1075704., 1083408., 1087584.,
      1091760., 1095936., 659580.,  662328.,  665076.,  667824.,  672744.,
      675504.,  678264.,  681024.,  686004.,  688776.,  691548.,  694320.,
      699360.,  702144.,  704928.,  707712.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      263484., 265560., 267636., 269712., 272904., 274992., 277080., 279168.,
      282420., 284520., 286620., 288720., 292032., 294144., 296256., 298368.,
      267756., 269880., 272004., 274128., 277368., 279504., 281640., 283776.,
      287076., 289224., 291372., 293520., 296880., 299040., 301200., 303360.,
      272028., 274200., 276372., 278544., 281832., 284016., 286200., 288384.,
      291732., 293928., 296124., 298320., 301728., 303936., 306144., 308352.,
      289116., 291480., 293844., 296208., 299688., 302064., 304440., 306816.,
      310356., 312744., 315132., 317520., 321120., 323520., 325920., 328320.,
      293388., 295800., 298212., 300624., 304152., 306576., 309000., 311424.,
      315012., 317448., 319884., 322320., 325968., 328416., 330864., 333312.,
      297660., 300120., 302580., 305040., 308616., 311088., 313560., 316032.,
      319668., 322152., 324636., 327120., 330816., 333312., 335808., 338304.,
      314748., 317400., 320052., 322704., 326472., 329136., 331800., 334464.,
      338292., 340968., 343644., 346320., 350208., 352896., 355584., 358272.,
      319020., 321720., 324420., 327120., 330936., 333648., 336360., 339072.,
      342948., 345672., 348396., 351120., 355056., 357792., 360528., 363264.,
      323292., 326040., 328788., 331536., 335400., 338160., 340920., 343680.,
      347604., 350376., 353148., 355920., 359904., 362688., 365472., 368256.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60738., 61404., 45090., 66066., 66732.,
                                         48978., 39756., 40152., 29400.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13785., 13956., 14127., 15153., 15324.,
                                         15495., 16521., 16692., 16863.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119028., 121476., 120324., 122808., 88317., 90180.,
      129396., 132132., 130692., 133464., 95877., 97956.,
      77688.,  79512.,  78456.,  80304.,  57414., 58800.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26508., 27570., 26832., 27912., 27156., 28254., 29100., 30306., 29424.,
      30648., 29748., 30990., 31692., 33042., 32016., 33384., 32340., 33726.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      235608., 238056., 240504., 242952., 238164., 240648., 243132., 245616.,
      174771., 176634., 178497., 180360., 256056., 258792., 261528., 264264.,
      258612., 261384., 264156., 266928., 189675., 191754., 193833., 195912.,
      153552., 155376., 157200., 159024., 155064., 156912., 158760., 160608.,
      113442., 114828., 116214., 117600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51954., 53016., 54078., 55140., 52584., 53664., 54744., 55824., 53214.,
      54312., 55410., 56508., 56994., 58200., 59406., 60612., 57624., 58848.,
      60072., 61296., 58254., 59496., 60738., 61980., 62034., 63384., 64734.,
      66084., 62664., 64032., 65400., 66768., 63294., 64680., 66066., 67452.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236760., 242952., 239352., 245616., 175689., 180360.,
      257496., 264264., 260088., 266928., 190809., 195912.,
      154608., 159024., 156144., 160608., 114270., 117600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52692., 55140., 53340., 55824., 53988., 56508., 57876., 60612., 58524.,
      61296., 59172., 61980., 63060., 66084., 63708., 66768., 64356., 67452.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      468660., 473520., 481008., 485904., 473772., 478704., 486264., 491232.,
      347679., 351378., 356994., 360720., 509556., 514992., 523056., 528528.,
      514668., 520176., 528312., 533856., 377487., 381618., 387666., 391824.,
      305592., 309216., 314400., 318048., 308616., 312288., 317520., 321216.,
      225786., 228540., 232428., 235200.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103278., 105384., 108156., 110280., 104538., 106680., 109488., 111648.,
      105798., 107976., 110820., 113016., 113358., 115752., 118812., 121224.,
      114618., 117048., 120144., 122592., 115878., 118344., 121476., 123960.,
      123438., 126120., 129468., 132168., 124698., 127416., 130800., 133536.,
      125958., 128712., 132132., 134904.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      932460.,  937320.,  942180.,  947040.,  957120.,  962016.,  966912.,
      971808.,  942612.,  947544.,  952476.,  957408.,  967560.,  972528.,
      977496.,  982464.,  691659.,  695358.,  699057.,  702756.,  710262.,
      713988.,  717714.,  721440.,  1013676., 1019112., 1024548., 1029984.,
      1040640., 1046112., 1051584., 1057056., 1023828., 1029336., 1034844.,
      1040352., 1051080., 1056624., 1062168., 1067712., 750843.,  754974.,
      759105.,  763236.,  771174.,  775332.,  779490.,  783648.,  607560.,
      611184.,  614808.,  618432.,  625152.,  628800.,  632448.,  636096.,
      613560.,  617232.,  620904.,  624576.,  631344.,  635040.,  638736.,
      642432.,  448818.,  451572.,  454326.,  457080.,  462084.,  464856.,
      467628.,  470400.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204450., 206556., 208662., 210768., 214188., 216312., 218436., 220560.,
      206934., 209076., 211218., 213360., 216816., 218976., 221136., 223296.,
      209418., 211596., 213774., 215952., 219444., 221640., 223836., 226032.,
      224322., 226716., 229110., 231504., 235212., 237624., 240036., 242448.,
      226806., 229236., 231666., 234096., 237840., 240288., 242736., 245184.,
      229290., 231756., 234222., 236688., 240468., 242952., 245436., 247920.,
      244194., 246876., 249558., 252240., 256236., 258936., 261636., 264336.,
      246678., 249396., 252114., 254832., 258864., 261600., 264336., 267072.,
      249162., 251916., 254670., 257424., 261492., 264264., 267036., 269808.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      934764.,  947040.,  959388.,  971808.,  944988.,  957408.,
      969900.,  982464.,  693495.,  702756.,  712071.,  721440.,
      1016556., 1029984., 1043484., 1057056., 1026780., 1040352.,
      1053996., 1067712., 753111.,  763236.,  773415.,  783648.,
      609672.,  618432.,  627240.,  636096.,  615720.,  624576.,
      633480.,  642432.,  450474.,  457080.,  463722.,  470400.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      205926., 210768., 215646., 220560., 208446., 213360., 218310., 223296.,
      210966., 215952., 220974., 226032., 226086., 231504., 236958., 242448.,
      228606., 234096., 239622., 245184., 231126., 236688., 242286., 247920.,
      246246., 252240., 258270., 264336., 248766., 254832., 260934., 267072.,
      251286., 257424., 263598., 269808.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1859844., 1869528., 1884360., 1894080., 1909020., 1918776., 1933824.,
      1943616., 1880148., 1889976., 1904952., 1914816., 1929900., 1939800.,
      1954992., 1964928., 1379619., 1386990., 1398114., 1405512., 1416717.,
      1424142., 1435428., 1442880., 2022276., 2033112., 2049096., 2059968.,
      2076060., 2086968., 2103168., 2114112., 2042580., 2053560., 2069688.,
      2080704., 2096940., 2107992., 2124336., 2135424., 1497987., 1506222.,
      1518210., 1526472., 1538541., 1546830., 1558980., 1567296., 1212120.,
      1219344., 1229616., 1236864., 1247208., 1254480., 1264896., 1272192.,
      1224120., 1231440., 1241808., 1249152., 1259592., 1266960., 1277472.,
      1284864., 895458.,  900948.,  908652.,  914160.,  921918.,  927444.,
      935256.,  940800.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      407658., 411852., 417324., 421536., 427062., 431292., 436872., 441120.,
      412626., 416892., 422436., 426720., 432318., 436620., 442272., 446592.,
      417594., 421932., 427548., 431904., 437574., 441948., 447672., 452064.,
      447402., 452172., 458220., 463008., 469110., 473916., 480072., 484896.,
      452370., 457212., 463332., 468192., 474366., 479244., 485472., 490368.,
      457338., 462252., 468444., 473376., 479622., 484572., 490872., 495840.,
      487146., 492492., 499116., 504480., 511158., 516540., 523272., 528672.,
      492114., 497532., 504228., 509664., 516414., 521868., 528672., 534144.,
      497082., 502572., 509340., 514848., 521670., 527196., 534072., 539616.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3710004., 3719688., 3729372., 3739056., 3759000., 3768720., 3778440.,
      3788160., 3808284., 3818040., 3827796., 3837552., 3857856., 3867648.,
      3877440., 3887232., 3750468., 3760296., 3770124., 3779952., 3800040.,
      3809904., 3819768., 3829632., 3849900., 3859800., 3869700., 3879600.,
      3900048., 3909984., 3919920., 3929856., 2751867., 2759238., 2766609.,
      2773980., 2788830., 2796228., 2803626., 2811024., 2826009., 2833434.,
      2840859., 2848284., 2863404., 2870856., 2878308., 2885760., 4033716.,
      4044552., 4055388., 4066224., 4087320., 4098192., 4109064., 4119936.,
      4141212., 4152120., 4163028., 4173936., 4195392., 4206336., 4217280.,
      4228224., 4074180., 4085160., 4096140., 4107120., 4128360., 4139376.,
      4150392., 4161408., 4182828., 4193880., 4204932., 4215984., 4237584.,
      4248672., 4259760., 4270848., 2987739., 2995974., 3004209., 3012444.,
      3028158., 3036420., 3044682., 3052944., 3068793., 3077082., 3085371.,
      3093660., 3109644., 3117960., 3126276., 3134592., 2417016., 2424240.,
      2431464., 2438688., 2451984., 2459232., 2466480., 2473728., 2487144.,
      2494416., 2501688., 2508960., 2522496., 2529792., 2537088., 2544384.,
      2440920., 2448240., 2455560., 2462880., 2476272., 2483616., 2490960.,
      2498304., 2511816., 2519184., 2526552., 2533920., 2547552., 2554944.,
      2562336., 2569728., 1785426., 1790916., 1796406., 1801896., 1811796.,
      1817304., 1822812., 1828320., 1838310., 1843836., 1849362., 1854888.,
      1864968., 1870512., 1876056., 1881600.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      811122.,  815316.,  819510.,  823704.,  830436.,  834648.,  838860.,
      843072.,  849894.,  854124.,  858354.,  862584.,  869496.,  873744.,
      877992.,  882240.,  820986.,  825252.,  829518.,  833784.,  840588.,
      844872.,  849156.,  853440.,  860334.,  864636.,  868938.,  873240.,
      880224.,  884544.,  888864.,  893184.,  830850.,  835188.,  839526.,
      843864.,  850740.,  855096.,  859452.,  863808.,  870774.,  875148.,
      879522.,  883896.,  890952.,  895344.,  899736.,  904128.,  890034.,
      894804.,  899574.,  904344.,  911652.,  916440.,  921228.,  926016.,
      933414.,  938220.,  943026.,  947832.,  955320.,  960144.,  964968.,
      969792.,  899898.,  904740.,  909582.,  914424.,  921804.,  926664.,
      931524.,  936384.,  943854.,  948732.,  953610.,  958488.,  966048.,
      970944.,  975840.,  980736.,  909762.,  914676.,  919590.,  924504.,
      931956.,  936888.,  941820.,  946752.,  954294.,  959244.,  964194.,
      969144.,  976776.,  981744.,  986712.,  991680.,  968946.,  974292.,
      979638.,  984984.,  992868.,  998232.,  1003596., 1008960., 1016934.,
      1022316., 1027698., 1033080., 1041144., 1046544., 1051944., 1057344.,
      978810.,  984228.,  989646.,  995064.,  1003020., 1008456., 1013892.,
      1019328., 1027374., 1032828., 1038282., 1043736., 1051872., 1057344.,
      1062816., 1068288., 988674.,  994164.,  999654.,  1005144., 1013172.,
      1018680., 1024188., 1029696., 1037814., 1043340., 1048866., 1054392.,
      1062600., 1068144., 1073688., 1079232.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35040., 51546., 33648., 37320., 54876.,
                                         35808., 25974., 38133., 24840.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12021., 12192., 12363., 12876., 13047.,
                                         13218., 13731., 13902., 14073.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68688., 70080., 101004., 103092., 65904., 67296.,
      73128., 74640., 107484., 109752., 70104., 71616.,
      50814., 51948., 74565.,  76266.,  48546., 49680.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23106., 24042., 23430., 24384., 23754., 24726., 24726., 25752., 25050.,
      26094., 25374., 26436., 26346., 27462., 26670., 27804., 26994., 28146.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135984., 137376., 138768., 140160., 199920., 202008., 204096., 206184.,
      130416., 131808., 133200., 134592., 144744., 146256., 147768., 149280.,
      212700., 214968., 217236., 219504., 138696., 140208., 141720., 143232.,
      100494., 101628., 102762., 103896., 147429., 149130., 150831., 152532.,
      95958.,  97092.,  98226.,  99360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45276., 46212., 47148., 48084., 45906., 46860., 47814., 48768., 46536.,
      47508., 48480., 49452., 48426., 49452., 50478., 51504., 49056., 50100.,
      51144., 52188., 49686., 50748., 51810., 52872., 51576., 52692., 53808.,
      54924., 52206., 53340., 54474., 55608., 52836., 53988., 55140., 56292.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      136488., 140160., 200712., 206184., 130968., 134592.,
      145368., 149280., 213672., 219504., 139368., 143232.,
      101016., 103896., 148239., 152532., 96516.,  99360.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45888., 48084., 46536., 48768., 47184., 49452., 49128., 51504., 49776.,
      52188., 50424., 52872., 52368., 54924., 53016., 55608., 53664., 56292.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      270216., 272976., 277536., 280320., 397284., 401424., 408192., 412368.,
      259176., 261936., 266400., 269184., 287736., 290736., 295536., 298560.,
      422844., 427344., 434472., 439008., 275736., 278736., 283440., 286464.,
      199782., 202032., 205524., 207792., 293103., 296478., 301662., 305064.,
      190782., 193032., 196452., 198720.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89922.,  91776.,  94296.,  96168.,  91182.,  93072.,  95628.,  97536.,
      92442.,  94368.,  96960.,  98904.,  96222.,  98256.,  100956., 103008.,
      97482.,  99552.,  102288., 104376., 98742.,  100848., 103620., 105744.,
      102522., 104736., 107616., 109848., 103782., 106032., 108948., 111216.,
      105042., 107328., 110280., 112584.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      537672., 540432., 543192., 545952., 552288., 555072., 557856., 560640.,
      790428., 794568., 798708., 802848., 812208., 816384., 820560., 824736.,
      515592., 518352., 521112., 523872., 530016., 532800., 535584., 538368.,
      572472., 575472., 578472., 581472., 588048., 591072., 594096., 597120.,
      841188., 845688., 850188., 854688., 864408., 868944., 873480., 878016.,
      548472., 551472., 554472., 557472., 563856., 566880., 569904., 572928.,
      397314., 399564., 401814., 404064., 408780., 411048., 413316., 415584.,
      582831., 586206., 589581., 592956., 599922., 603324., 606726., 610128.,
      379314., 381564., 383814., 386064., 390636., 392904., 395172., 397440.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177990., 179844., 181698., 183552., 186720., 188592., 190464., 192336.,
      180474., 182364., 184254., 186144., 189348., 191256., 193164., 195072.,
      182958., 184884., 186810., 188736., 191976., 193920., 195864., 197808.,
      190410., 192444., 194478., 196512., 199860., 201912., 203964., 206016.,
      192894., 194964., 197034., 199104., 202488., 204576., 206664., 208752.,
      195378., 197484., 199590., 201696., 205116., 207240., 209364., 211488.,
      202830., 205044., 207258., 209472., 213000., 215232., 217464., 219696.,
      205314., 207564., 209814., 212064., 215628., 217896., 220164., 222432.,
      207798., 210084., 212370., 214656., 218256., 220560., 222864., 225168.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      538680., 545952., 553272., 560640., 792012., 802848., 813756., 824736.,
      516696., 523872., 531096., 538368., 573720., 581472., 589272., 597120.,
      843132., 854688., 866316., 878016., 549816., 557472., 565176., 572928.,
      398358., 404064., 409806., 415584., 584451., 592956., 601515., 610128.,
      380430., 386064., 391734., 397440.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179214., 183552., 187926., 192336., 181734., 186144., 190590., 195072.,
      184254., 188736., 193254., 197808., 191814., 196512., 201246., 206016.,
      194334., 199104., 203910., 208752., 196854., 201696., 206574., 211488.,
      204414., 209472., 214566., 219696., 206934., 212064., 217230., 222432.,
      209454., 214656., 219894., 225168.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1071864., 1077360., 1086384., 1091904., 1101000., 1106544., 1115712.,
      1121280., 1575780., 1584024., 1597416., 1605696., 1619196., 1627512.,
      1641120., 1649472., 1027896., 1033392., 1042224., 1047744., 1056648.,
      1062192., 1071168., 1076736., 1141464., 1147440., 1156944., 1162944.,
      1172520., 1178544., 1188192., 1194240., 1677300., 1686264., 1700376.,
      1709376., 1723596., 1732632., 1746960., 1756032., 1093656., 1099632.,
      1108944., 1114944., 1124328., 1130352., 1139808., 1145856., 792234.,
      796716.,  803628.,  808128.,  815094.,  819612.,  826632.,  831168.,
      1162179., 1168902., 1179162., 1185912., 1196253., 1203030., 1213452.,
      1220256., 756378.,  760860.,  767628.,  772128.,  778950.,  783468.,
      790344.,  794880.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      354738., 358428., 363396., 367104., 372126., 375852., 380928., 384672.,
      359706., 363468., 368508., 372288., 377382., 381180., 386328., 390144.,
      364674., 368508., 373620., 377472., 382638., 386508., 391728., 395616.,
      379578., 383628., 388956., 393024., 398406., 402492., 407928., 412032.,
      384546., 388668., 394068., 398208., 403662., 407820., 413328., 417504.,
      389514., 393708., 399180., 403392., 408918., 413148., 418728., 422976.,
      404418., 408828., 414516., 418944., 424686., 429132., 434928., 439392.,
      409386., 413868., 419628., 424128., 429942., 434460., 440328., 444864.,
      414354., 418908., 424740., 429312., 435198., 439788., 445728., 450336.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2138232., 2143728., 2149224., 2154720., 2167248., 2172768., 2178288.,
      2183808., 2196456., 2202000., 2207544., 2213088., 2225856., 2231424.,
      2236992., 2242560., 3143316., 3151560., 3159804., 3168048., 3186552.,
      3194832., 3203112., 3211392., 3230076., 3238392., 3246708., 3255024.,
      3273888., 3282240., 3290592., 3298944., 2050296., 2055792., 2061288.,
      2066784., 2078928., 2084448., 2089968., 2095488., 2107752., 2113296.,
      2118840., 2124384., 2136768., 2142336., 2147904., 2153472., 2276952.,
      2282928., 2288904., 2294880., 2307888., 2313888., 2319888., 2325888.,
      2339016., 2345040., 2351064., 2357088., 2370336., 2376384., 2382432.,
      2388480., 3345636., 3354600., 3363564., 3372528., 3391752., 3400752.,
      3409752., 3418752., 3438156., 3447192., 3456228., 3465264., 3484848.,
      3493920., 3502992., 3512064., 2181336., 2187312., 2193288., 2199264.,
      2211888., 2217888., 2223888., 2229888., 2242632., 2248656., 2254680.,
      2260704., 2273568., 2279616., 2285664., 2291712., 1579986., 1584468.,
      1588950., 1593432., 1602756., 1607256., 1611756., 1616256., 1625670.,
      1630188., 1634706., 1639224., 1648728., 1653264., 1657800., 1662336.,
      2317635., 2324358., 2331081., 2337804., 2351574., 2358324., 2365074.,
      2371824., 2385729., 2392506., 2399283., 2406060., 2420100., 2426904.,
      2433708., 2440512., 1508274., 1512756., 1517238., 1521720., 1530756.,
      1535256., 1539756., 1544256., 1553382., 1557900., 1562418., 1566936.,
      1576152., 1580688., 1585224., 1589760.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705786., 709476., 713166., 716856., 723084., 726792., 730500., 734208.,
      740526., 744252., 747978., 751704., 758112., 761856., 765600., 769344.,
      715650., 719412., 723174., 726936., 733236., 737016., 740796., 744576.,
      750966., 754764., 758562., 762360., 768840., 772656., 776472., 780288.,
      725514., 729348., 733182., 737016., 743388., 747240., 751092., 754944.,
      761406., 765276., 769146., 773016., 779568., 783456., 787344., 791232.,
      755106., 759156., 763206., 767256., 773844., 777912., 781980., 786048.,
      792726., 796812., 800898., 804984., 811752., 815856., 819960., 824064.,
      764970., 769092., 773214., 777336., 783996., 788136., 792276., 796416.,
      803166., 807324., 811482., 815640., 822480., 826656., 830832., 835008.,
      774834., 779028., 783222., 787416., 794148., 798360., 802572., 806784.,
      813606., 817836., 822066., 826296., 833208., 837456., 841704., 845952.,
      804426., 808836., 813246., 817656., 824604., 829032., 833460., 837888.,
      844926., 849372., 853818., 858264., 865392., 869856., 874320., 878784.,
      814290., 818772., 823254., 827736., 834756., 839256., 843756., 848256.,
      855366., 859884., 864402., 868920., 876120., 880656., 885192., 889728.,
      824154., 828708., 833262., 837816., 844908., 849480., 854052., 858624.,
      865806., 870396., 874986., 879576., 886848., 891456., 896064., 900672.};
  const std::array<int, 4> in_shape = {{3, 8, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61446., 62112., 40548., 65442., 66108.,
                                         43140., 45477., 45936., 29925.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14355., 14526., 14697., 15381., 15552.,
                                         15723., 16407., 16578., 16749.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120408., 122892., 121704., 124224., 79416., 81096.,
      128184., 130884., 129480., 132216., 84456., 86280.,
      88929.,  90954.,  89820.,  91872.,  58482., 59850.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27594., 28710., 27918., 29052., 28242., 29394., 29538., 30762., 29862.,
      31104., 30186., 31446., 31482., 32814., 31806., 33156., 32130., 33498.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238332., 240816., 243300., 245784., 240888., 243408., 245928., 248448.,
      157152., 158832., 160512., 162192., 253668., 256368., 259068., 261768.,
      256224., 258960., 261696., 264432., 167088., 168912., 170736., 172560.,
      175833., 177858., 179883., 181908., 177588., 179640., 181692., 183744.,
      115596., 116964., 118332., 119700.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54072., 55188., 56304., 57420., 54702., 55836., 56970., 58104., 55332.,
      56484., 57636., 58788., 57852., 59076., 60300., 61524., 58482., 59724.,
      60966., 62208., 59112., 60372., 61632., 62892., 61632., 62964., 64296.,
      65628., 62262., 63612., 64962., 66312., 62892., 64260., 65628., 66996.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      239520., 245784., 242112., 248448., 157992., 162192.,
      255072., 261768., 257664., 264432., 168072., 172560.,
      176967., 181908., 178749., 183744., 116388., 119700.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54864., 57420., 55512., 58104., 56160., 58788., 58752., 61524., 59400.,
      62208., 60048., 62892., 62640., 65628., 63288., 66312., 63936., 66996.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474108., 479040., 486600., 491568., 479220., 484224., 491856., 496896.,
      312648., 315984., 321024., 324384., 504780., 510144., 518136., 523536.,
      509892., 515328., 523392., 528864., 332520., 336144., 341472., 345120.,
      349911., 353934., 359766., 363816., 353421., 357498., 363384., 367488.,
      230058., 232776., 236664., 239400.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107514., 109728., 112608., 114840., 108774., 111024., 113940., 116208.,
      110034., 112320., 115272., 117576., 115074., 117504., 120600., 123048.,
      116334., 118800., 121932., 124416., 117594., 120096., 123264., 125784.,
      122634., 125280., 128592., 131256., 123894., 126576., 129924., 132624.,
      125154., 127872., 131256., 133992.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      943284.,  948216.,  953148.,  958080.,  968232.,  973200.,  978168.,
      983136.,  953436.,  958440.,  963444.,  968448.,  978672.,  983712.,
      988752.,  993792.,  621960.,  625296.,  628632.,  631968.,  638688.,
      642048.,  645408.,  648768.,  1004196., 1009560., 1014924., 1020288.,
      1030872., 1036272., 1041672., 1047072., 1014348., 1019784., 1025220.,
      1030656., 1041312., 1046784., 1052256., 1057728., 661416.,  665040.,
      668664.,  672288.,  679296.,  682944.,  686592.,  690240.,  695799.,
      699822.,  703845.,  707868.,  715482.,  719532.,  723582.,  727632.,
      702765.,  706842.,  710919.,  714996.,  722664.,  726768.,  730872.,
      734976.,  457398.,  460116.,  462834.,  465552.,  470592.,  473328.,
      476064.,  478800.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212814., 215028., 217242., 219456., 222984., 225216., 227448., 229680.,
      215298., 217548., 219798., 222048., 225612., 227880., 230148., 232416.,
      217782., 220068., 222354., 224640., 228240., 230544., 232848., 235152.,
      227718., 230148., 232578., 235008., 238752., 241200., 243648., 246096.,
      230202., 232668., 235134., 237600., 241380., 243864., 246348., 248832.,
      232686., 235188., 237690., 240192., 244008., 246528., 249048., 251568.,
      242622., 245268., 247914., 250560., 254520., 257184., 259848., 262512.,
      245106., 247788., 250470., 253152., 257148., 259848., 262548., 265248.,
      247590., 250308., 253026., 255744., 259776., 262512., 265248., 267984.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      945660.,  958080.,  970572.,  983136.,  955884.,  968448.,
      981084.,  993792.,  623640.,  631968.,  640344.,  648768.,
      1007004., 1020288., 1033644., 1047072., 1017228., 1030656.,
      1044156., 1057728., 663384.,  672288.,  681240.,  690240.,
      698067.,  707868.,  717723.,  727632.,  705087.,  714996.,
      724959.,  734976.,  458982.,  465552.,  472158.,  478800.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      214398., 219456., 224550., 229680., 216918., 222048., 227214., 232416.,
      219438., 224640., 229878., 235152., 229518., 235008., 240534., 246096.,
      232038., 237600., 243198., 248832., 234558., 240192., 245862., 251568.,
      244638., 250560., 256518., 262512., 247158., 253152., 259182., 265248.,
      249678., 255744., 261846., 267984.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1881492., 1891320., 1906296., 1916160., 1931244., 1941144., 1956336.,
      1966272., 1901796., 1911768., 1926888., 1936896., 1952124., 1962168.,
      1977504., 1987584., 1240632., 1247280., 1257264., 1263936., 1273992.,
      1280688., 1290816., 1297536., 2003316., 2014008., 2029848., 2040576.,
      2056524., 2067288., 2083344., 2094144., 2023620., 2034456., 2050440.,
      2061312., 2077404., 2088312., 2104512., 2115456., 1319544., 1326768.,
      1337328., 1344576., 1355208., 1362480., 1373184., 1380480., 1388115.,
      1396134., 1407690., 1415736., 1427373., 1435446., 1447164., 1455264.,
      1402047., 1410174., 1421838., 1429992., 1441737., 1449918., 1461744.,
      1469952., 912546.,  917964.,  925668.,  931104.,  938862.,  944316.,
      952128.,  957600.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      424386., 428796., 434484., 438912., 444654., 449100., 454896., 459360.,
      429354., 433836., 439596., 444096., 449910., 454428., 460296., 464832.,
      434322., 438876., 444708., 449280., 455166., 459756., 465696., 470304.,
      454194., 459036., 465156., 470016., 476190., 481068., 487296., 492192.,
      459162., 464076., 470268., 475200., 481446., 486396., 492696., 497664.,
      464130., 469116., 475380., 480384., 486702., 491724., 498096., 503136.,
      484002., 489276., 495828., 501120., 507726., 513036., 519696., 525024.,
      488970., 494316., 500940., 506304., 512982., 518364., 525096., 530496.,
      493938., 499356., 506052., 511488., 518238., 523692., 530496., 535968.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3753156., 3762984., 3772812., 3782640., 3802728., 3812592., 3822456.,
      3832320., 3852588., 3862488., 3872388., 3882288., 3902736., 3912672.,
      3922608., 3932544., 3793620., 3803592., 3813564., 3823536., 3843768.,
      3853776., 3863784., 3873792., 3894204., 3904248., 3914292., 3924336.,
      3944928., 3955008., 3965088., 3975168., 2474616., 2481264., 2487912.,
      2494560., 2507856., 2514528., 2521200., 2527872., 2541288., 2547984.,
      2554680., 2561376., 2574912., 2581632., 2588352., 2595072., 3995940.,
      4006632., 4017324., 4028016., 4048968., 4059696., 4070424., 4081152.,
      4102284., 4113048., 4123812., 4134576., 4155888., 4166688., 4177488.,
      4188288., 4036404., 4047240., 4058076., 4068912., 4090008., 4100880.,
      4111752., 4122624., 4143900., 4154808., 4165716., 4176624., 4198080.,
      4209024., 4219968., 4230912., 2631864., 2639088., 2646312., 2653536.,
      2667408., 2674656., 2681904., 2689152., 2703144., 2710416., 2717688.,
      2724960., 2739072., 2746368., 2753664., 2760960., 2768211., 2776230.,
      2784249., 2792268., 2807334., 2815380., 2823426., 2831472., 2846673.,
      2854746., 2862819., 2870892., 2886228., 2894328., 2902428., 2910528.,
      2795967., 2804094., 2812221., 2820348., 2835522., 2843676., 2851830.,
      2859984., 2875293., 2883474., 2891655., 2899836., 2915280., 2923488.,
      2931696., 2939904., 1819674., 1825092., 1830510., 1835928., 1845900.,
      1851336., 1856772., 1862208., 1872270., 1877724., 1883178., 1888632.,
      1898784., 1904256., 1909728., 1915200.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      844362.,  848772.,  853182.,  857592.,  864540.,  868968.,  873396.,
      877824.,  884862.,  889308.,  893754.,  898200.,  905328.,  909792.,
      914256.,  918720.,  854226.,  858708.,  863190.,  867672.,  874692.,
      879192.,  883692.,  888192.,  895302.,  899820.,  904338.,  908856.,
      916056.,  920592.,  925128.,  929664.,  864090.,  868644.,  873198.,
      877752.,  884844.,  889416.,  893988.,  898560.,  905742.,  910332.,
      914922.,  919512.,  926784.,  931392.,  936000.,  940608.,  903546.,
      908388.,  913230.,  918072.,  925452.,  930312.,  935172.,  940032.,
      947502.,  952380.,  957258.,  962136.,  969696.,  974592.,  979488.,
      984384.,  913410.,  918324.,  923238.,  928152.,  935604.,  940536.,
      945468.,  950400.,  957942.,  962892.,  967842.,  972792.,  980424.,
      985392.,  990360.,  995328.,  923274.,  928260.,  933246.,  938232.,
      945756.,  950760.,  955764.,  960768.,  968382.,  973404.,  978426.,
      983448.,  991152.,  996192.,  1001232., 1006272., 962730.,  968004.,
      973278.,  978552.,  986364.,  991656.,  996948.,  1002240., 1010142.,
      1015452., 1020762., 1026072., 1034064., 1039392., 1044720., 1050048.,
      972594.,  977940.,  983286.,  988632.,  996516.,  1001880., 1007244.,
      1012608., 1020582., 1025964., 1031346., 1036728., 1044792., 1050192.,
      1055592., 1060992., 982458.,  987876.,  993294.,  998712.,  1006668.,
      1012104., 1017540., 1022976., 1031022., 1036476., 1041930., 1047384.,
      1055520., 1060992., 1066464., 1071936.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {144920., 146096., 107856.,
                                         154328., 155504., 114768.,
                                         107202., 108012., 79614.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {42642., 43020., 43398., 45666., 46044.,
                                         46422., 48690., 49068., 49446.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      285424., 289840., 287728., 292192., 212364., 215712.,
      303856., 308656., 306160., 311008., 225900., 229536.,
      210804., 214404., 212388., 216024., 156501., 159228.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83043., 85284., 83772., 86040., 84501., 86796., 88875., 91332., 89604.,
      92088., 90333., 92844., 94707., 97380., 95436., 98136., 96165., 98892.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      566432., 570848., 575264., 579680., 570992., 575456., 579920., 584384.,
      421380., 424728., 428076., 431424., 602912., 607712., 612512., 617312.,
      607472., 612320., 617168., 622016., 448164., 451800., 455436., 459072.,
      418008., 421608., 425208., 428808., 421140., 424776., 428412., 432048.,
      310275., 313002., 315729., 318456.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163845., 166086., 168327., 170568., 165276., 167544., 169812., 172080.,
      166707., 169002., 171297., 173592., 175293., 177750., 180207., 182664.,
      176724., 179208., 181692., 184176., 178155., 180666., 183177., 185688.,
      186741., 189414., 192087., 194760., 188172., 190872., 193572., 196272.,
      189603., 192330., 195057., 197784.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      568544., 579680., 573152., 584384., 423036., 431424.,
      605408., 617312., 610016., 622016., 450108., 459072.,
      420024., 428808., 423192., 432048., 311841., 318456.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165357., 170568., 166815., 172080., 168273., 173592.,
      177021., 182664., 178479., 184176., 179937., 185688.,
      188685., 194760., 190143., 196272., 191601., 197784.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1128304., 1137088., 1150528., 1159360., 1137424., 1146304.,
      1159840., 1168768., 839412.,  846072.,  856152.,  862848.,
      1201264., 1210816., 1225024., 1234624., 1210384., 1220032.,
      1234336., 1244032., 892980.,  900216.,  910872.,  918144.,
      832884.,  840048.,  850416.,  857616.,  839148.,  846384.,
      856824.,  864096.,  618255.,  623682.,  631458.,  636912.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      326259., 330714., 336654., 341136., 329121., 333630., 339624., 344160.,
      331983., 336546., 342594., 347184., 349155., 354042., 360414., 365328.,
      352017., 356958., 363384., 368352., 354879., 359874., 366354., 371376.,
      372051., 377370., 384174., 389520., 374913., 380286., 387144., 392544.,
      377775., 383202., 390114., 395568.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2247824., 2256608., 2265392., 2274176., 2292224., 2301056., 2309888.,
      2318720., 2265968., 2274848., 2283728., 2292608., 2310752., 2319680.,
      2328608., 2337536., 1672164., 1678824., 1685484., 1692144., 1705608.,
      1712304., 1719000., 1725696., 2392976., 2402528., 2412080., 2421632.,
      2440448., 2450048., 2459648., 2469248., 2411120., 2420768., 2430416.,
      2440064., 2458976., 2468672., 2478368., 2488064., 1778724., 1785960.,
      1793196., 1800432., 1814472., 1821744., 1829016., 1836288., 1658604.,
      1665768., 1672932., 1680096., 1693632., 1700832., 1708032., 1715232.,
      1671060., 1678296., 1685532., 1692768., 1706376., 1713648., 1720920.,
      1728192., 1231083., 1236510., 1241937., 1247364., 1257462., 1262916.,
      1268370., 1273824.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      648063., 652518., 656973., 661428., 668826., 673308., 677790., 682272.,
      653733., 658242., 662751., 667260., 674712., 679248., 683784., 688320.,
      659403., 663966., 668529., 673092., 680598., 685188., 689778., 694368.,
      693423., 698310., 703197., 708084., 715914., 720828., 725742., 730656.,
      699093., 704034., 708975., 713916., 721800., 726768., 731736., 736704.,
      704763., 709758., 714753., 719748., 727686., 732708., 737730., 742752.,
      738783., 744102., 749421., 754740., 763002., 768348., 773694., 779040.,
      744453., 749826., 755199., 760572., 768888., 774288., 779688., 785088.,
      750123., 755550., 760977., 766404., 774774., 780228., 785682., 791136.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2252048., 2274176., 2296400., 2318720., 2270288., 2292608.,
      2315024., 2337536., 1675476., 1692144., 1708884., 1725696.,
      2397968., 2421632., 2445392., 2469248., 2416208., 2440064.,
      2464016., 2488064., 1782612., 1800432., 1818324., 1836288.,
      1662636., 1680096., 1697628., 1715232., 1675164., 1692768.,
      1710444., 1728192., 1234215., 1247364., 1260567., 1273824.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      651087., 661428., 671823., 682272., 656811., 667260., 677763., 688320.,
      662535., 673092., 683703., 694368., 696879., 708084., 719343., 730656.,
      702603., 713916., 725283., 736704., 708327., 719748., 731223., 742752.,
      742671., 754740., 766863., 779040., 748395., 760572., 772803., 785088.,
      754119., 766404., 778743., 791136.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4486576., 4504096., 4530784., 4548352., 4575184., 4592800., 4619776.,
      4637440., 4522864., 4540576., 4567456., 4585216., 4612240., 4630048.,
      4657216., 4675072., 3337668., 3350952., 3370968., 3384288., 3404412.,
      3417768., 3438000., 3451392., 4776880., 4795936., 4824160., 4843264.,
      4871632., 4890784., 4919296., 4938496., 4813168., 4832416., 4860832.,
      4880128., 4908688., 4928032., 4956736., 4976128., 3550788., 3565224.,
      3586392., 3600864., 3622140., 3636648., 3658032., 3672576., 3310980.,
      3325272., 3345864., 3360192., 3380892., 3395256., 3416064., 3430464.,
      3335892., 3350328., 3371064., 3385536., 3406380., 3420888., 3441840.,
      3456384., 2457603., 2468430., 2483874., 2494728., 2510253., 2521134.,
      2536740., 2547648.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1293291., 1302174., 1313946., 1322856., 1334709., 1343646., 1355580.,
      1364544., 1304631., 1313622., 1325502., 1334520., 1346481., 1355526.,
      1367568., 1376640., 1315971., 1325070., 1337058., 1346184., 1358253.,
      1367406., 1379556., 1388736., 1384011., 1393758., 1406394., 1416168.,
      1428885., 1438686., 1451484., 1461312., 1395351., 1405206., 1417950.,
      1427832., 1440657., 1450566., 1463472., 1473408., 1406691., 1416654.,
      1429506., 1439496., 1452429., 1462446., 1475460., 1485504., 1474731.,
      1485342., 1498842., 1509480., 1523061., 1533726., 1547388., 1558080.,
      1486071., 1496790., 1510398., 1521144., 1534833., 1545606., 1559376.,
      1570176., 1497411., 1508238., 1521954., 1532808., 1546605., 1557486.,
      1571364., 1582272.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8955632., 8973152., 8990672., 9008192., 9044000., 9061568., 9079136.,
      9096704., 9132752., 9150368., 9167984., 9185600., 9221888., 9239552.,
      9257216., 9274880., 9028016., 9045728., 9063440., 9081152., 9117152.,
      9134912., 9152672., 9170432., 9206672., 9224480., 9242288., 9260096.,
      9296576., 9314432., 9332288., 9350144., 6662052., 6675336., 6688620.,
      6701904., 6728616., 6741936., 6755256., 6768576., 6795468., 6808824.,
      6822180., 6835536., 6862608., 6876000., 6889392., 6902784., 9534704.,
      9553760., 9572816., 9591872., 9629216., 9648320., 9667424., 9686528.,
      9724112., 9743264., 9762416., 9781568., 9819392., 9838592., 9857792.,
      9876992., 9607088., 9626336., 9645584., 9664832., 9702368., 9721664.,
      9740960., 9760256., 9798032., 9817376., 9836720., 9856064., 9894080.,
      9913472., 9932864., 9952256., 7087140., 7101576., 7116012., 7130448.,
      7158312., 7172784., 7187256., 7201728., 7229772., 7244280., 7258788.,
      7273296., 7301520., 7316064., 7330608., 7345152., 6607668., 6621960.,
      6636252., 6650544., 6677400., 6691728., 6706056., 6720384., 6747420.,
      6761784., 6776148., 6790512., 6817728., 6832128., 6846528., 6860928.,
      6657348., 6671784., 6686220., 6700656., 6727656., 6742128., 6756600.,
      6771072., 6798252., 6812760., 6827268., 6841776., 6869136., 6883680.,
      6898224., 6912768., 4904379., 4915206., 4926033., 4936860., 4956894.,
      4967748., 4978602., 4989456., 5009625., 5020506., 5031387., 5042268.,
      5062572., 5073480., 5084388., 5095296.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2577699., 2586582., 2595465., 2604348., 2618982., 2627892., 2636802.,
      2645712., 2660481., 2669418., 2678355., 2687292., 2702196., 2711160.,
      2720124., 2729088., 2600271., 2609262., 2618253., 2627244., 2641986.,
      2651004., 2660022., 2669040., 2683917., 2692962., 2702007., 2711052.,
      2726064., 2735136., 2744208., 2753280., 2622843., 2631942., 2641041.,
      2650140., 2664990., 2674116., 2683242., 2692368., 2707353., 2716506.,
      2725659., 2734812., 2749932., 2759112., 2768292., 2777472., 2758275.,
      2768022., 2777769., 2787516., 2803014., 2812788., 2822562., 2832336.,
      2847969., 2857770., 2867571., 2877372., 2893140., 2902968., 2912796.,
      2922624., 2780847., 2790702., 2800557., 2810412., 2826018., 2835900.,
      2845782., 2855664., 2871405., 2881314., 2891223., 2901132., 2917008.,
      2926944., 2936880., 2946816., 2803419., 2813382., 2823345., 2833308.,
      2849022., 2859012., 2869002., 2878992., 2894841., 2904858., 2914875.,
      2924892., 2940876., 2950920., 2960964., 2971008., 2938851., 2949462.,
      2960073., 2970684., 2987046., 2997684., 3008322., 3018960., 3035457.,
      3046122., 3056787., 3067452., 3084084., 3094776., 3105468., 3116160.,
      2961423., 2972142., 2982861., 2993580., 3010050., 3020796., 3031542.,
      3042288., 3058893., 3069666., 3080439., 3091212., 3107952., 3118752.,
      3129552., 3140352., 2983995., 2994822., 3005649., 3016476., 3033054.,
      3043908., 3054762., 3065616., 3082329., 3093210., 3104091., 3114972.,
      3131820., 3142728., 3153636., 3164544.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}